huff doesnt work

2 files changed, 81 insertions, 4 deletions

diff --git a/lvc/src/bin/main.rs b/lvc/src/bin/main.rs
index d5c9bbe..e579f72 100644
--- a/lvc/src/bin/main.rs
+++ b/lvc/src/bin/main.rs
@@ -3,6 +3,7 @@ use lvc::{
     debug::draw_debug,
     decode::decode,
     encode::{encode, EncodeConfig},
+    huff::{read_huffman, write_huffman},
     Block, Frame, Pixel, PixelValue, View, P2,
 };
 use std::{
@@ -58,7 +59,15 @@ fn main() {
             let mut stdout = BufWriter::new(stdout());
 
             loop {
-                let b = Block::read(&mut stdin, View::all(size)).unwrap();
+                let mut buf = vec![];
+                read_huffman(&mut stdin, &mut buf).unwrap();
+
+                eprintln!("{:?}", &buf[..20]);
+                let b = {
+                    let mut buf = std::io::Cursor::new(&mut buf);
+                    Block::read(&mut buf, View::all(size)).unwrap()
+                };
+
                 decode(&last_frame, &mut frame, View::all(size), &b);
 
                 if let Some(debug_frame) = &mut debug_frame {
@@ -94,12 +103,34 @@ fn main() {
 
                 let t = Instant::now();
                 let b: Block = encode(&last_frame, &frame, View::all(size), &config);
-                eprintln!("frame {frame_number} took {:?}", t.elapsed());
-
-                b.write(&mut stdout);
+                let time_encode = t.elapsed();
 
+                let t = Instant::now();
                 decode(&last_frame, &mut frame, View::all(size), &b);
                 last_frame = frame;
+                let time_decode = t.elapsed();
+
+                let mut buf = vec![];
+                let mut bufw = std::io::Cursor::new(&mut buf);
+                b.write(&mut bufw).unwrap();
+                drop(bufw);
+                let t = Instant::now();
+                let bits_raw = buf.len() * 8;
+                // eprintln!("{:?}", &buf[..20]);
+                let bits_huff = write_huffman(&buf, &mut stdout).unwrap();
+                let time_huff = t.elapsed();
+                drop(buf);
+
+                eprintln!(
+                    "frame {frame_number}: {:?}",
+                    time_decode + time_huff + time_encode
+                );
+                eprintln!("\tencode {time_encode:?}");
+                eprintln!("\tdecode {time_decode:?}");
+                eprintln!(
+                    "\thuff {time_huff:?} ({}%)",
+                    ((bits_huff as f32 / bits_raw as f32) * 100.0).round()
+                );
             }
         }
     }
diff --git a/lvc/src/bin/test.rs b/lvc/src/bin/test.rs
new file mode 100644
index 0000000..0f630d3
--- /dev/null
+++ b/lvc/src/bin/test.rs
@@ -0,0 +1,46 @@
+#[cfg(test)]
+mod test {
+
+    use lvc::huff::{read_huffman, write_huffman, BitIO};
+    use std::io::Cursor;
+
+    #[test]
+    fn test_bitio() {
+        let mut buf = Vec::<u8>::new();
+
+        {
+            let mut b = BitIO::new(Cursor::new(&mut buf));
+            b.wbit(true).unwrap();
+            b.wbit(true).unwrap();
+            b.wbit(true).unwrap();
+            b.wbit(true).unwrap();
+            b.wbit(false).unwrap();
+            b.wbit(true).unwrap();
+            b.wbit(true).unwrap();
+            b.wbit(true).unwrap();
+            b.wbit(true).unwrap();
+            b.flush().unwrap();
+        }
+        {
+            let mut b = BitIO::new(Cursor::new(&mut buf));
+            for _ in 0..9 {
+                eprintln!("{:?}", b.rbit().unwrap())
+            }
+        }
+    }
+
+    #[test]
+    fn test_huff() {
+        let a = vec![1; 10000];
+        let mut b = vec![];
+
+        let mut buf = Vec::<u8>::new();
+        write_huffman(&a, &mut Cursor::new(&mut buf)).unwrap();
+        eprintln!("out {buf:x?}");
+        read_huffman(&mut Cursor::new(&mut buf), &mut b).unwrap();
+
+        assert_eq!(a, b)
+    }
+}
+
+fn main() {}