fixing huff 1/2

2 files changed, 73 insertions, 62 deletions

diff --git a/lvc/src/bin/main.rs b/lvc/src/bin/main.rs
index e579f72..7c0d965 100644
--- a/lvc/src/bin/main.rs
+++ b/lvc/src/bin/main.rs
@@ -3,7 +3,7 @@ use lvc::{
     debug::draw_debug,
     decode::decode,
     encode::{encode, EncodeConfig},
-    huff::{read_huffman, write_huffman},
+    huff::{read_huff, write_huff},
     Block, Frame, Pixel, PixelValue, View, P2,
 };
 use std::{
@@ -50,38 +50,6 @@ fn main() {
         y: args.height as i32,
     };
     match args.action {
-        Action::Decode { debug } => {
-            let mut frame = Frame::new(size);
-            let mut last_frame = Frame::new(size);
-            let mut debug_frame = if debug { Some(Frame::new(size)) } else { None };
-
-            let mut stdin = BufReader::new(stdin());
-            let mut stdout = BufWriter::new(stdout());
-
-            loop {
-                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 {
-                    debug_frame.pixels.copy_from_slice(&frame.pixels);
-                    draw_debug(debug_frame, View::all(size), &b);
-                    write_frame(&mut stdout, &debug_frame);
-                } else {
-                    write_frame(&mut stdout, &frame);
-                }
-
-                last_frame.pixels.copy_from_slice(&frame.pixels); // TODO use mem::swap
-                frame.pixels.iter_mut().for_each(|e| *e = Pixel::BLACK);
-            }
-        }
         Action::Encode {
             max_block_size,
             threshold,
@@ -92,12 +60,13 @@ fn main() {
                 max_block_size,
                 iters,
             };
-
             let mut last_frame = Frame::new(size);
 
             let mut stdin = BufReader::new(stdin());
             let mut stdout = BufWriter::new(stdout());
 
+            let huff = true;
+
             for frame_number in 0.. {
                 let mut frame = read_frame(&mut stdin, size);
 
@@ -110,27 +79,68 @@ fn main() {
                 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);
+                if huff {
+                    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;
+                    let bits_huff = write_huff(&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()
-                );
+                    eprintln!(
+                        "frame {frame_number}: {:?}",
+                        time_decode + time_huff + time_encode
+                    );
+                    eprintln!(
+                        "\tencode {time_encode:?} ({}%)",
+                        ((bits_raw as f32 / (size.area() * 24) as f32) * 100.0).round()
+                    );
+                    eprintln!(
+                        "\thuff {time_huff:?} ({}%)",
+                        ((bits_huff as f32 / bits_raw as f32) * 100.0).round()
+                    );
+                    eprintln!("\tdecode {time_decode:?}");
+                } else {
+                    b.write(&mut stdout).unwrap();
+                }
+            }
+        }
+        Action::Decode { debug } => {
+            let mut frame = Frame::new(size);
+            let mut last_frame = Frame::new(size);
+            let mut debug_frame = if debug { Some(Frame::new(size)) } else { None };
+
+            let mut stdin = BufReader::new(stdin());
+            let mut stdout = BufWriter::new(stdout());
+
+            let huff = true;
+
+            loop {
+                
+                let b = if huff {
+                    let mut buf = vec![];
+                    read_huff(&mut stdin, &mut buf).unwrap();
+                    let mut buf = std::io::Cursor::new(&mut buf);
+                    Block::read(&mut buf, View::all(size)).unwrap()
+                } else {
+                    Block::read(&mut stdin, View::all(size)).unwrap()
+                };
+
+                decode(&last_frame, &mut frame, View::all(size), &b);
+
+                if let Some(debug_frame) = &mut debug_frame {
+                    debug_frame.pixels.copy_from_slice(&frame.pixels);
+                    draw_debug(debug_frame, View::all(size), &b);
+                    write_frame(&mut stdout, &debug_frame);
+                } else {
+                    write_frame(&mut stdout, &frame);
+                }
+
+                last_frame.pixels.copy_from_slice(&frame.pixels); // TODO use mem::swap
+                frame.pixels.iter_mut().for_each(|e| *e = Pixel::BLACK);
             }
         }
     }
diff --git a/lvc/src/bin/test.rs b/lvc/src/bin/test.rs
index 0f630d3..f4e0ed4 100644
--- a/lvc/src/bin/test.rs
+++ b/lvc/src/bin/test.rs
@@ -1,7 +1,7 @@
 #[cfg(test)]
 mod test {
 
-    use lvc::huff::{read_huffman, write_huffman, BitIO};
+    use lvc::huff::{read_huff, write_huff, BitIO};
     use std::io::Cursor;
 
     #[test]
@@ -19,26 +19,27 @@ mod test {
             b.wbit(true).unwrap();
             b.wbit(true).unwrap();
             b.wbit(true).unwrap();
+            b.wbyte(0xff).unwrap();
             b.flush().unwrap();
         }
         {
             let mut b = BitIO::new(Cursor::new(&mut buf));
-            for _ in 0..9 {
-                eprintln!("{:?}", b.rbit().unwrap())
+            for _ in 0..17 {
+                let _v = b.rbit().unwrap();
+                // eprintln!("{:?}", _v)
             }
         }
     }
 
     #[test]
     fn test_huff() {
-        let a = vec![1; 10000];
+        let a = vec![1, 2, 3, 4, 5, 1, 3, 6, 3, 2, 4, 6, 7, 4, 3, 2, 1, 3, 4];
         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();
-
+        write_huff(&a, &mut Cursor::new(&mut buf)).unwrap();
+        read_huff(&mut Cursor::new(&mut buf), &mut b).unwrap();
+        
         assert_eq!(a, b)
     }
 }