splitting

4 files changed, 70 insertions, 13 deletions

diff --git a/evc/src/bin/encode.rs b/evc/src/bin/encode.rs
index c932fe9..8d37443 100644
--- a/evc/src/bin/encode.rs
+++ b/evc/src/bin/encode.rs
@@ -1,5 +1,8 @@
 use clap::Parser;
-use evc::{frame::Frame};
+use evc::{
+    block::{Block, BlockInner},
+    frame::{Frame, View},
+};
 use std::io::{self, BufReader};
 
 #[derive(Parser)]
@@ -23,10 +26,30 @@ fn main() -> io::Result<()> {
         println!("frame {i}");
         let frame = Frame::read(&mut input, size)?;
 
-        
+        let v1 = frame.view((0, 0), size);
+        let v2 = prev_frame.view((0, 0), size);
+
+        encode_block(v1, v2);
 
         prev_frame = frame;
     }
 
     Ok(())
 }
+
+fn encode_block(view: View, prev: View) -> Block {
+    let diff = View::diff(&view, &prev);
+
+    let inner = if diff > 100_000.0 {
+        let [a, b] = view.split();
+        let [ap, bp] = prev.split();
+        BlockInner::Split(Box::new([encode_block(a, ap), encode_block(b, bp)]))
+    } else {
+        todo!()
+    };
+
+    Block {
+        size: view.size,
+        inner,
+    }
+}
diff --git a/evc/src/block.rs b/evc/src/block.rs
index 05ff56d..261882a 100644
--- a/evc/src/block.rs
+++ b/evc/src/block.rs
@@ -5,8 +5,8 @@ use crate::{
 
 #[derive(Clone, Debug)]
 pub struct Block {
-    size: (usize, usize),
-    inner: BlockInner,
+    pub size: (usize, usize),
+    pub inner: BlockInner,
 }
 
 #[derive(Clone, Debug)]
diff --git a/evc/src/frame.rs b/evc/src/frame.rs
index 1c18620..1906555 100644
--- a/evc/src/frame.rs
+++ b/evc/src/frame.rs
@@ -28,24 +28,29 @@ impl Frame {
         }
         Ok(frame)
     }
+    pub fn view<'a>(&'a self, offset: (usize, usize), size: (usize, usize)) -> View<'a> {
+        View::new(self, offset, size)
+    }
 }
 
 impl Index<(usize, usize)> for Frame {
     type Output = Pixel;
+    #[inline]
     fn index(&self, (x, y): (usize, usize)) -> &Self::Output {
         &self.buffer[x][y]
     }
 }
 impl IndexMut<(usize, usize)> for Frame {
+    #[inline]
     fn index_mut(&mut self, (x, y): (usize, usize)) -> &mut Self::Output {
         &mut self.buffer[x][y]
     }
 }
 
 pub struct View<'a> {
-    frame: &'a Frame,
-    offset: (usize, usize),
-    size: (usize, usize),
+    pub frame: &'a Frame,
+    pub offset: (usize, usize),
+    pub size: (usize, usize),
 }
 
 impl<'a> View<'a> {
@@ -56,22 +61,50 @@ impl<'a> View<'a> {
             size,
         }
     }
-    pub fn diff(&self, rhs: &Self) -> f64 {
-        assert_eq!(self.size, rhs.size);
+    pub fn diff(va: &Self, vb: &Self) -> f64 {
+        assert_eq!(va.size, vb.size);
         let mut acc = 0.0;
-        for x in 0..self.size.0 {
-            for y in 0..self.size.1 {
-                let a = self[(x, y)];
-                let b = rhs[(x, y)];
+        for x in 0..va.size.0 {
+            for y in 0..va.size.1 {
+                let a = va[(x, y)];
+                let b = vb[(x, y)];
                 acc += Pixel::distance(a, b);
             }
         }
         acc
     }
+    pub fn split(&self) -> [Self; 2] {
+        let vert = self.size.0 > self.size.1;
+        [
+            Self {
+                frame: self.frame,
+                offset: self.offset,
+                size: if vert {
+                    (self.size.0 / 2, self.size.1)
+                } else {
+                    (self.size.0, self.size.1 / 2)
+                },
+            },
+            Self {
+                frame: self.frame,
+                offset: if vert {
+                    (self.offset.0 + self.size.0 / 2, self.offset.1)
+                } else {
+                    (self.offset.0, self.offset.1 + self.size.1 / 2)
+                },
+                size: if vert {
+                    (self.size.0 - self.size.0 / 2, self.size.1)
+                } else {
+                    (self.size.0, self.size.1 - self.size.1 / 2)
+                },
+            },
+        ]
+    }
 }
 
 impl Index<(usize, usize)> for View<'_> {
     type Output = Pixel;
+    #[inline]
     fn index(&self, (x, y): (usize, usize)) -> &Self::Output {
         &self.frame[(x + self.offset.0, y + self.offset.1)]
     }
diff --git a/evc/src/pixel.rs b/evc/src/pixel.rs
index 559dedc..442c1b5 100644
--- a/evc/src/pixel.rs
+++ b/evc/src/pixel.rs
@@ -19,6 +19,7 @@ impl Ser for Pixel {
 }
 
 impl Pixel {
+    #[inline]
     pub fn distance(a: Pixel, b: Pixel) -> f64 {
         let (rd, gd, bd) = (
             a.r.abs_diff(b.r) as f64,