test2

1 files changed, 114 insertions, 0 deletions

diff --git a/mtree-test/src/main.rs b/mtree-test/src/main.rs
new file mode 100644
index 0000000..3952722
--- /dev/null
+++ b/mtree-test/src/main.rs
@@ -0,0 +1,114 @@
+pub mod decode;
+pub mod encode;
+
+use decode::Dec;
+use encode::Enc;
+use framework::bitstream_filter_main;
+use glam::{I16Vec2, i16vec2};
+use std::{collections::VecDeque, env::args, ops::Range};
+
+fn main() -> Result<(), std::io::Error> {
+    match args().nth(1).unwrap().as_str() {
+        "enc" => bitstream_filter_main::<Enc>(),
+        "dec" => bitstream_filter_main::<Dec>(),
+        _ => panic!("unknown mode"),
+    }
+}
+
+pub const BLOCK_SIZE: i16 = 8;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct AbsRef {
+    pub off: I16Vec2,
+    pub frame: u64,
+}
+
+#[derive(Clone)]
+pub struct Frame(pub Vec<u8>);
+
+impl Frame {
+    pub fn new(res: I16Vec2) -> Self {
+        let res = res.as_usizevec2();
+        Self(vec![0; res.x * res.y + 2 * (res.x / 2 * res.y / 2)])
+    }
+
+    pub fn index(&self, res: I16Vec2, p: I16Vec2) -> [usize; 3] {
+        let res = res.as_usizevec2();
+        let p = p.as_usizevec2();
+
+        let ystride = res.y;
+        let ysize = res.x * ystride;
+        let uvstride = res.x / 2;
+        let usize = uvstride * (res.y / 2);
+        let puv = p / 2;
+        [
+            p.x + p.y * ystride,
+            ysize + puv.x + puv.y * uvstride,
+            ysize + usize + puv.x + puv.y * uvstride,
+        ]
+    }
+    pub fn slice(&self, res: I16Vec2, y: i16, x: Range<i16>) -> [&[u8]; 3] {
+        let start = self.index(res, i16vec2(x.start, y));
+        let end = self.index(res, i16vec2(x.end, y));
+        [
+            &self.0[start[0]..end[0]],
+            &self.0[start[1]..end[1]],
+            &self.0[start[2]..end[2]],
+        ]
+    }
+    pub fn get(&self, res: I16Vec2, p: I16Vec2) -> [u8; 3] {
+        self.index(res, p).map(|i| self.0[i])
+    }
+
+    pub fn export_rect(&self, res: I16Vec2, r: Range<I16Vec2>, out: &mut Vec<u8>) {
+        for y in r.start.y..r.end.y {
+            let slices = self.slice(res, y, r.start.x..r.end.x);
+            out.extend(slices[0]);
+            out.extend(slices[1]);
+            out.extend(slices[2]);
+        }
+    }
+    pub fn import_rect(&mut self, res: I16Vec2, r: Range<I16Vec2>, mut data: &[u8]) -> usize {
+        let mut off = 0;
+        for y in r.start.y..r.end.y {
+            let start = self.index(res, i16vec2(r.start.x, y));
+            let end = self.index(res, i16vec2(r.end.x, y));
+
+            let mut do_slice = |s: &mut [u8]| {
+                s.copy_from_slice(&data[..s.len()]);
+                data = &data[s.len()..];
+                off += s.len();
+            };
+
+            do_slice(&mut self.0[start[0]..end[0]]);
+            do_slice(&mut self.0[start[1]..end[1]]);
+            do_slice(&mut self.0[start[2]..end[2]]);
+        }
+        off
+    }
+}
+
+pub fn frame_to_frame_rect_copy(
+    res: I16Vec2,
+    aframe: &mut Frame,
+    bframe: &Frame,
+    size: I16Vec2,
+    aoff: I16Vec2,
+    boff: I16Vec2,
+) {
+    for y in 0..size.y {
+        let astart = aframe.index(res, i16vec2(aoff.x, aoff.y + y));
+        let aend = aframe.index(res, i16vec2(aoff.x + size.x, aoff.y + y));
+        let bstart = bframe.index(res, i16vec2(boff.x, boff.y + y));
+        let bend = bframe.index(res, i16vec2(boff.x + size.x, boff.y + y));
+
+        aframe.0[astart[0]..aend[0]].copy_from_slice(&bframe.0[bstart[0]..bend[0]]);
+        aframe.0[astart[1]..aend[1]].copy_from_slice(&bframe.0[bstart[1]..bend[1]]);
+        aframe.0[astart[2]..aend[2]].copy_from_slice(&bframe.0[bstart[2]..bend[2]]);
+    }
+}
+
+pub struct LastFrames {
+    pub frame_offset: u64,
+    pub frames: VecDeque<Frame>,
+}