Cleanup (#137)

* refactor!: use upstream arithmetic-coding library

* Clean up dead code, fix broken bench, and trim hot-path overhead

Fix the workspace build (framed_to_adder_hd.rs bench used removed
Framed/SimulProcArgs/SimulProcessor APIs from the arithmetic-coding
refactor). Remove dead code surfaced by clippy: the entirely-unused
d_controller module, ~390 lines of commented-out Bevy-era UI in
adder-viz, unused struct fields/test helpers, and panic/todo! trait
impls kept only to satisfy bounds. Fix clippy warnings (unused
vars/imports, swallowed Results, a vec![x; n] pattern that silently
dropped Vec capacity) and strip stray dbg!/eprintln! debug leftovers,
including one firing every frame in a hot path.

Performance: replace a linear D_SHIFT scan in the per-event pixel
integration path with a leading_zeros()-based bit-length lookup,
preallocate a 3D pixel buffer instead of growing it via nested
push(), and write DVS text events directly instead of building an
intermediate String per event.

All existing tests pass; cargo fmt and clippy are clean.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* Fix busy loop

* Update adder.rs

---------

Co-authored-by: daniel.eades <daniel.eades@seebyte.com>
Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: 3 people

.idea/runConfigurations/Test_stable.xml

@@ -18,13 +18,12 @@ exclude = [
 
 [features]
 default = ["compression"]
-compression = ["dep:arithmetic-coding-adder-dep"]
+compression = ["dep:arithmetic-coding"]
 
 [dependencies]
-arithmetic-coding-adder-dep = { path = "../arithmetic-coding-adder-dep", version = "0.3.3", optional = true }
-#arithmetic-coding-adder-dep = { version = "0.3.1", optional = true }
+arithmetic-coding = { version = "0.4.0", optional = true }
 bincode = "1.3.3"
-bitstream-io = "2.5.3"
+bitstream-io = "2.6.0"
 enum_dispatch = "0.3.11"
 fenwick = "2.0.1"
 float-cmp = "0.9.0"

adder-codec-core/Cargo.toml

@@ -1,7 +1,7 @@
 // From https://github.com/danieleades/arithmetic-coding. Only temporary, for initial testing.
 //! Fenwick tree based context-switching model
 
-use arithmetic_coding_adder_dep::Model;
+use arithmetic_coding::Model;
 
 use super::Weights;
 use crate::codec::compressed::fenwick::ValueError;

adder-codec-core/src/codec/compressed/fenwick/context_switching.rs

@@ -0,0 +1,224 @@
+use crate::codec::compressed::fenwick::context_switching::FenwickModel;
+use crate::codec::compressed::source_model::cabac_contexts::{
+    Contexts, BITSHIFT_ENCODE_FULL, D_RESIDUAL_OFFSET,
+};
+use crate::codec::compressed::{DResidual, TResidual, DRESIDUAL_NO_EVENT, DRESIDUAL_SKIP_CUBE};
+use crate::{AbsoluteT, DeltaT};
+use arithmetic_coding::Model;
+use std::mem::size_of;
+
+const D_RESIDUAL_BYTES: usize = size_of::<DResidual>();
+
+#[derive(Debug, Clone)]
+enum Phase {
+    Header {
+        bytes_remaining: usize,
+    },
+    IntraD,
+    IntraBitshift,
+    IntraT {
+        bytes_remaining: usize,
+    },
+    InterD {
+        bytes_remaining: usize,
+        d_buf: [u8; 2],
+    },
+    InterBitshift,
+    InterT {
+        bytes_remaining: usize,
+    },
+    Eof,
+}
+
+impl Phase {
+    fn context(&self, contexts: &Contexts) -> usize {
+        match self {
+            Phase::Header { .. } | Phase::IntraT { .. } | Phase::InterT { .. } => {
+                contexts.t_context
+            }
+            Phase::IntraD | Phase::InterD { .. } => contexts.d_context,
+            Phase::IntraBitshift | Phase::InterBitshift => contexts.bitshift_context,
+            Phase::Eof => contexts.eof_context,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct FacadeModel {
+    inner: FenwickModel,
+    contexts: Contexts,
+    phase: Phase,
+}
+
+impl FacadeModel {
+    #[must_use]
+    pub fn new(dt_ref: DeltaT, max_denominator: u64) -> Self {
+        let mut inner = FenwickModel::with_symbols(u16::MAX as usize, max_denominator);
+        let contexts = Contexts::new(&mut inner, dt_ref);
+        let phase = Phase::Header {
+            bytes_remaining: size_of::<AbsoluteT>(),
+        };
+        let mut model = Self {
+            inner,
+            contexts,
+            phase,
+        };
+        model.inner.set_context(model.contexts.t_context);
+        model
+    }
+
+    pub fn contexts(&self) -> &Contexts {
+        &self.contexts
+    }
+
+    pub fn begin_intra(&mut self) {
+        self.phase = Phase::IntraD;
+        self.inner.set_context(self.contexts.d_context);
+    }
+
+    pub fn begin_inter(&mut self) {
+        self.phase = Phase::InterD {
+            bytes_remaining: D_RESIDUAL_BYTES,
+            d_buf: [0; 2],
+        };
+        self.inner.set_context(self.contexts.d_context);
+    }
+
+    pub fn begin_eof(&mut self) {
+        self.phase = Phase::Eof;
+        self.inner.set_context(self.contexts.eof_context);
+    }
+
+    fn advance_phase(&mut self, symbol: Option<&usize>) {
+        let symbol = symbol.copied();
+        let phase = std::mem::replace(&mut self.phase, Phase::Eof);
+        let next_phase = match phase {
+            Phase::Header {
+                mut bytes_remaining,
+            } => {
+                bytes_remaining = bytes_remaining.saturating_sub(1);
+                Phase::Header { bytes_remaining }
+            }
+            Phase::IntraD => match symbol {
+                Some(value) => {
+                    let no_event = (DRESIDUAL_NO_EVENT + D_RESIDUAL_OFFSET) as usize;
+                    let skip = (DRESIDUAL_SKIP_CUBE + D_RESIDUAL_OFFSET) as usize;
+                    if value == no_event || value == skip {
+                        Phase::IntraD
+                    } else {
+                        Phase::IntraBitshift
+                    }
+                }
+                None => Phase::IntraD,
+            },
+            Phase::IntraBitshift => match symbol {
+                Some(value) => Phase::IntraT {
+                    bytes_remaining: t_residual_bytes(value),
+                },
+                None => Phase::IntraBitshift,
+            },
+            Phase::IntraT {
+                mut bytes_remaining,
+            } => {
+                bytes_remaining = bytes_remaining.saturating_sub(1);
+                if bytes_remaining == 0 {
+                    Phase::IntraD
+                } else {
+                    Phase::IntraT { bytes_remaining }
+                }
+            }
+            Phase::InterD {
+                mut bytes_remaining,
+                mut d_buf,
+            } => match symbol {
+                Some(value) => {
+                    let byte = value as u8;
+                    if bytes_remaining == D_RESIDUAL_BYTES {
+                        d_buf[0] = byte;
+                        bytes_remaining -= 1;
+                        Phase::InterD {
+                            bytes_remaining,
+                            d_buf,
+                        }
+                    } else {
+                        d_buf[1] = byte;
+                        let d_residual = DResidual::from_be_bytes(d_buf);
+                        if d_residual == DRESIDUAL_NO_EVENT {
+                            Phase::InterD {
+                                bytes_remaining: D_RESIDUAL_BYTES,
+                                d_buf: [0; 2],
+                            }
+                        } else {
+                            Phase::InterBitshift
+                        }
+                    }
+                }
+                None => Phase::InterD {
+                    bytes_remaining,
+                    d_buf,
+                },
+            },
+            Phase::InterBitshift => match symbol {
+                Some(value) => Phase::InterT {
+                    bytes_remaining: t_residual_bytes(value),
+                },
+                None => Phase::InterBitshift,
+            },
+            Phase::InterT {
+                mut bytes_remaining,
+            } => {
+                bytes_remaining = bytes_remaining.saturating_sub(1);
+                if bytes_remaining == 0 {
+                    Phase::InterD {
+                        bytes_remaining: D_RESIDUAL_BYTES,
+                        d_buf: [0; 2],
+                    }
+                } else {
+                    Phase::InterT { bytes_remaining }
+                }
+            }
+            Phase::Eof => Phase::Eof,
+        };
+        self.phase = next_phase;
+        let context = self.phase.context(&self.contexts);
+        self.inner.set_context(context);
+    }
+}
+
+impl Model for FacadeModel {
+    type B = u64;
+    type Symbol = usize;
+    type ValueError = crate::codec::compressed::fenwick::ValueError;
+
+    fn probability(
+        &self,
+        symbol: Option<&Self::Symbol>,
+    ) -> Result<std::ops::Range<Self::B>, Self::ValueError> {
+        self.inner.probability(symbol)
+    }
+
+    fn denominator(&self) -> Self::B {
+        self.inner.denominator()
+    }
+
+    fn max_denominator(&self) -> Self::B {
+        self.inner.max_denominator()
+    }
+
+    fn symbol(&self, value: Self::B) -> Option<Self::Symbol> {
+        self.inner.symbol(value)
+    }
+
+    fn update(&mut self, symbol: Option<&Self::Symbol>) {
+        self.inner.update(symbol);
+        self.advance_phase(symbol);
+    }
+}
+
+fn t_residual_bytes(bitshift_value: usize) -> usize {
+    if bitshift_value as u8 == BITSHIFT_ENCODE_FULL {
+        size_of::<i64>()
+    } else {
+        size_of::<TResidual>()
+    }
+}

adder-codec-core/src/codec/compressed/fenwick/facade.rs

@@ -4,6 +4,7 @@
 use std::ops::Range;
 
 pub mod context_switching;
+pub mod facade;
 pub mod simple;
 
 /// A wrapper around a vector of fenwick counts, with one additional weight for

adder-codec-core/src/codec/compressed/fenwick/mod.rs

@@ -2,7 +2,7 @@
 #![allow(missing_docs, unused)]
 //! simple adaptive model using a fenwick tree
 
-use arithmetic_coding_adder_dep::Model;
+use arithmetic_coding::Model;
 
 use super::Weights;
 use crate::codec::compressed::fenwick::ValueError;

adder-codec-core/src/codec/compressed/fenwick/simple.rs

@@ -1,9 +1,8 @@
 use crate::codec::compressed::fenwick::context_switching::FenwickModel;
 use crate::codec::compressed::fenwick::Weights;
 use crate::{AbsoluteT, DeltaT, EventCoordless, Intensity, D, D_SHIFT};
-use arithmetic_coding_adder_dep::Encoder;
-use bitstream_io::{BigEndian, BitWrite, BitWriter};
 
+#[derive(Clone, Debug)]
 pub struct Contexts {
     /// Decimation factor residuals context
     pub(crate) d_context: usize,
@@ -224,16 +223,4 @@ pub fn d_residual_default_weights() -> Weights {
     Weights::new_with_counts(counts.len(), &Vec::from(counts))
 }
 
-pub fn eof_context(
-    contexts: &Contexts,
-    encoder: &mut Encoder<FenwickModel, BitWriter<Vec<u8>, BigEndian>>,
-    stream: &mut BitWriter<Vec<u8>, BigEndian>,
-) {
-    // THIS IS CRUCIAL FOR TESTING
-    let eof_context = contexts.eof_context;
-    encoder.model.set_context(eof_context);
-    encoder.encode(None, stream).unwrap();
-    encoder.flush(stream).unwrap();
-    stream.byte_align().unwrap();
-    stream.flush().unwrap();
-}
+// EOF handling is done by the facade model and top-level encoder flow.