Continue work

Author: friendlymatthew

src/bin/test_suite.rs

@@ -2,7 +2,7 @@ use anyhow::{anyhow, Result};
 use comfy_table::{Attribute, Cell, Color, Table};
 use iris::{
     png::{grammar::Png, PngDecoder},
-    util::test_file_parser::{parse_test_file, PNGSuiteTestCase},
+    test_file_parser::{parse_test_file, PNGSuiteTestCase},
 };
 use std::{ffi::OsStr, fmt, fs, panic};
 

src/util/event_log.rs src/event_log.rssrc/util/event_log.rs renamed to src/event_log.rs

@@ -50,7 +50,7 @@ macro_rules! impl_read_slice {
         }
 
         #[allow(dead_code)]
-        fn peek_slice(&mut self, len: usize) -> Result<&'a [u8]> {
+        fn peek_slice(&self, len: usize) -> Result<&'a [u8]> {
             self.data
                 .get(self.cursor..self.cursor + len)
                 .ok_or_else(|| anyhow::anyhow!("oob"))

src/util/read_bytes.rs src/impl_read.rssrc/util/read_bytes.rs renamed to src/impl_read.rs

@@ -1,13 +1,13 @@
 use crate::{
     impl_read_for_datatype, impl_read_slice,
     jpeg::grammar::{
-        Component, EncodingProcess, HuffmanTable, Jpeg, Marker, Precision, QuantizationTable,
-        StartOfFrame, StartOfScan, JFIF,
+        ApplicationHeader, Component, EncodingProcess, HuffmanTable, Jpeg, Marker, Precision,
+        QuantizationTable, StartOfFrame, StartOfScan, JFIF,
     },
 };
 
 use anyhow::{anyhow, ensure, Result};
-use std::ops::{Range, RangeInclusive};
+use std::ops::RangeInclusive;
 
 #[derive(Debug)]
 pub struct JpegDecoder<'a> {
@@ -28,9 +28,10 @@ impl<'a> JpegDecoder<'a> {
         todo!();
     }
 
-    fn parse_jfif(&mut self) -> Result<JFIF> {
+    fn parse_jfif(&mut self) -> Result<JFIF<'a>> {
         ensure!(self.read_marker()? == 0xFFD8);
 
+        let mut application_header = None;
         let mut quantization_tables = Vec::with_capacity(4);
         let mut huffman_tables = Vec::new();
         let mut start_of_frame = None;
@@ -40,7 +41,7 @@ impl<'a> JpegDecoder<'a> {
         loop {
             match self.read_marker()? {
                 0xFFE0 => {
-                    self.parse_application_header()?;
+                    application_header = Some(self.parse_application_header()?);
                 }
                 0xFFDB => {
                     quantization_tables.push(self.parse_quantization_table()?);
@@ -55,7 +56,10 @@ impl<'a> JpegDecoder<'a> {
 
                     break;
                 }
-                start_of_frame_marker if (start_of_frame_marker as u8 & 0xF0) == 0xC0 => {
+                start_of_frame_marker
+                    if start_of_frame_marker >> 8 == 0xFF
+                        && (start_of_frame_marker as u8 & 0xF0) == 0xC0 =>
+                {
                     ensure!(start_of_frame.is_none());
                     start_of_frame = Some(self.parse_start_of_frame(start_of_frame_marker as u8)?);
                 }
@@ -66,6 +70,8 @@ impl<'a> JpegDecoder<'a> {
         ensure!(self.read_marker()? == 0xFFD9);
 
         Ok(JFIF {
+            application_header: application_header
+                .ok_or_else(|| anyhow!("expected application header"))?,
             quantization_tables,
             huffman_tables: {
                 ensure!(huffman_tables.len() == 4);
@@ -77,15 +83,22 @@ impl<'a> JpegDecoder<'a> {
         })
     }
 
-    fn parse_application_header(&mut self) -> Result<()> {
+    fn parse_application_header(&mut self) -> Result<ApplicationHeader> {
         let offset = self.cursor;
-        let length = self.read_u16()?;
+        let length = self.read_u16()? as usize;
 
         ensure!(self.read_slice(5)? == b"JFIF\0");
 
-        self.cursor = offset + length as usize;
+        let app_header = ApplicationHeader {
+            version: (self.read_u8()?, self.read_u8()?),
+            unit: self.read_u8()?,
+            density: (self.read_u16()?, self.read_u16()?),
+            thumbnail: (self.read_u8()?, self.read_u8()?),
+        };
 
-        Ok(())
+        ensure!(self.cursor == offset + length);
+
+        Ok(app_header)
     }
 
     fn parse_quantization_table(&mut self) -> Result<QuantizationTable> {
@@ -148,28 +161,19 @@ impl<'a> JpegDecoder<'a> {
         let length = self.read_u16()? as usize;
 
         let flag = self.read_u8()?;
+        let code_lengths = self.read_fixed_array::<16, _>(Self::read_u8)?;
+        let num_values = code_lengths.iter().sum::<u8>();
+        let values = self.read_vec(num_values as usize, Self::read_u8)?;
 
-        let huffman_table = HuffmanTable {
+        let ht = HuffmanTable {
             flag,
-            code_lengths: {
-                let code_lengths = Range {
-                    start: self.cursor,
-                    end: self.cursor + 16,
-                };
-
-                self.cursor += 16;
-
-                code_lengths
-            },
-            symbols: Range {
-                start: self.cursor,
-                end: offset + length,
-            },
+            code_lengths,
+            values,
         };
 
-        self.cursor = offset + length;
+        ensure!(self.cursor == offset + length);
 
-        Ok(huffman_table)
+        Ok(ht)
     }
 
     fn parse_start_of_scan(&mut self) -> Result<StartOfScan> {
@@ -192,35 +196,37 @@ impl<'a> JpegDecoder<'a> {
         Ok(start_of_scan)
     }
 
-    fn parse_image_data(&mut self) -> Result<Range<usize>> {
-        let range = Range {
-            start: self.cursor,
-            end: {
-                while self.peek_slice(2)? != [0xFF, 0xD9] {
-                    self.cursor += 1;
-                }
+    fn parse_image_data(&mut self) -> Result<&'a [u8]> {
+        let len = self.count_until(|this| Ok(this.peek_slice(2)? != [0xFF, 0xD9]))?;
 
-                self.cursor
-            },
-        };
-
-        Ok(range)
+        self.read_slice(len)
     }
 
     impl_read_for_datatype!(read_u8, u8);
     impl_read_for_datatype!(read_u16, u16);
     impl_read_for_datatype!(read_marker, Marker);
     impl_read_slice!();
+
+    /// counts the number of bytes until the reader reaches term function
+    fn count_until(&self, term_fn: impl Fn(&Self) -> Result<bool>) -> Result<usize> {
+        let mut len = 0;
+
+        while !term_fn(self)? {
+            len += 1;
+        }
+
+        Ok(len)
+    }
 }
 
-// #[cfg(test)]
-// mod tests {
-//     use super::*;
+#[cfg(test)]
+mod tests {
+    use super::*;
 
-//     #[test]
-//     fn test_decode_taxi_zone_map_manhattan() {
-//         let data = std::fs::read("./tests/taxi_zone_map_manhattan.jpg").unwrap();
+    #[test]
+    fn test_decode_taxi_zone_map_manhattan() {
+        let data = std::fs::read("./tests/taxi_zone_map_manhattan.jpg").unwrap();
 
-//         let _ = JpegDecoder::new(&data).decode().unwrap();
-//     }
-// }
+        let _ = JpegDecoder::new(&data).decode().unwrap();
+    }
+}

src/jpeg/decoder.rs

@@ -1,12 +1,17 @@
 use crate::image::grammar::{ColorType, ImageExt};
 use anyhow::bail;
-use std::{
-    borrow::Cow,
-    ops::{Range, RangeInclusive},
-};
+use std::{borrow::Cow, ops::RangeInclusive};
 
 pub type Marker = u16;
 
+#[derive(Debug)]
+pub struct ApplicationHeader {
+    pub version: (u8, u8),
+    pub unit: u8,
+    pub density: (u16, u16),
+    pub thumbnail: (u8, u8),
+}
+
 #[derive(Debug, Clone, Copy)]
 pub enum Precision {
     Eight = 1,
@@ -16,9 +21,9 @@ pub enum Precision {
 impl From<bool> for Precision {
     fn from(value: bool) -> Self {
         if value {
-            Precision::Sixteen
+            Self::Sixteen
         } else {
-            Precision::Eight
+            Self::Eight
         }
     }
 }
@@ -42,11 +47,30 @@ impl QuantizationTable {
     }
 }
 
+pub enum HuffmanTableClass {
+    AC,
+    DC,
+}
+
 #[derive(Debug)]
 pub struct HuffmanTable {
     pub flag: u8,
-    pub code_lengths: Range<usize>,
-    pub symbols: Range<usize>,
+    pub code_lengths: [u8; 16],
+    pub values: Vec<u8>,
+}
+
+impl HuffmanTable {
+    pub const fn table_class(&self) -> HuffmanTableClass {
+        if (self.flag >> 4) == 1 {
+            return HuffmanTableClass::AC;
+        }
+
+        HuffmanTableClass::DC
+    }
+
+    pub const fn table_identifier(&self) -> u8 {
+        self.flag & 0b1111
+    }
 }
 
 #[derive(Debug)]
@@ -103,12 +127,13 @@ pub struct StartOfScan {
 }
 
 #[derive(Debug)]
-pub struct JFIF {
+pub struct JFIF<'a> {
+    pub application_header: ApplicationHeader,
     pub quantization_tables: Vec<QuantizationTable>,
     pub huffman_tables: Vec<HuffmanTable>,
     pub start_of_frame: StartOfFrame,
     pub start_of_scan: StartOfScan,
-    pub image_data: Range<usize>,
+    pub image_data: &'a [u8],
 }
 
 #[derive(Debug)]

src/jpeg/grammar.rs

@@ -1,5 +1,4 @@
-pub use decoder::*;
+mod decoder;
 
 pub mod grammar;
-
-mod decoder;
+pub use decoder::*;

src/jpeg/mod.rs

@@ -9,3 +9,7 @@ pub mod jpeg;
 pub mod png;
 pub mod renderer;
 pub mod util;
+
+pub mod event_log;
+pub(crate) mod impl_read;
+pub mod test_file_parser;

src/lib.rs

@@ -243,7 +243,7 @@ impl<'a> PngDecoder<'a> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{image::grammar::ImageExt, util::test_file_parser::parse_test_file};
+    use crate::{image::grammar::ImageExt, test_file_parser::parse_test_file};
     use anyhow::anyhow;
     use image::ImageReader;
     use pretty_assertions::assert_eq;

src/png/decoder.rs

@@ -1,4 +1 @@
-pub mod event_log;
 
-pub(crate) mod read_bytes;
-pub mod test_file_parser;