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>

Author: ac-freeman

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

@@ -11,13 +11,22 @@ const D_RESIDUAL_BYTES: usize = size_of::<DResidual>();
 
 #[derive(Debug, Clone)]
 enum Phase {
-    Header { bytes_remaining: usize },
+    Header {
+        bytes_remaining: usize,
+    },
     IntraD,
     IntraBitshift,
-    IntraT { bytes_remaining: usize },
-    InterD { bytes_remaining: usize, d_buf: [u8; 2] },
+    IntraT {
+        bytes_remaining: usize,
+    },
+    InterD {
+        bytes_remaining: usize,
+        d_buf: [u8; 2],
+    },
     InterBitshift,
-    InterT { bytes_remaining: usize },
+    InterT {
+        bytes_remaining: usize,
+    },
     Eof,
 }
 
@@ -84,10 +93,10 @@ impl FacadeModel {
         let symbol = symbol.copied();
         let phase = std::mem::replace(&mut self.phase, Phase::Eof);
         let next_phase = match phase {
-            Phase::Header { mut bytes_remaining } => {
-                if bytes_remaining > 0 {
-                    bytes_remaining -= 1;
-                }
+            Phase::Header {
+                mut bytes_remaining,
+            } => {
+                bytes_remaining = bytes_remaining.saturating_sub(1);
                 Phase::Header { bytes_remaining }
             }
             Phase::IntraD => match symbol {
@@ -108,10 +117,10 @@ impl FacadeModel {
                 },
                 None => Phase::IntraBitshift,
             },
-            Phase::IntraT { mut bytes_remaining } => {
-                if bytes_remaining > 0 {
-                    bytes_remaining -= 1;
-                }
+            Phase::IntraT {
+                mut bytes_remaining,
+            } => {
+                bytes_remaining = bytes_remaining.saturating_sub(1);
                 if bytes_remaining == 0 {
                     Phase::IntraD
                 } else {
@@ -155,10 +164,10 @@ impl FacadeModel {
                 },
                 None => Phase::InterBitshift,
             },
-            Phase::InterT { mut bytes_remaining } => {
-                if bytes_remaining > 0 {
-                    bytes_remaining -= 1;
-                }
+            Phase::InterT {
+                mut bytes_remaining,
+            } => {
+                bytes_remaining = bytes_remaining.saturating_sub(1);
                 if bytes_remaining == 0 {
                     Phase::InterD {
                         bytes_remaining: D_RESIDUAL_BYTES,

adder-codec-core/src/codec/compressed/source_model/event_structure/event_adu.rs

@@ -170,10 +170,8 @@ impl EventAdu {
 
         for block_idx_y in 0..self.event_cubes.nrows() {
             for block_idx_x in 0..self.event_cubes.ncols() {
-                self.event_cubes[[block_idx_y, block_idx_x]].decompress_inter(
-                    &mut decoder,
-                    &contexts,
-                );
+                self.event_cubes[[block_idx_y, block_idx_x]]
+                    .decompress_inter(&mut decoder, &contexts);
                 debug_assert_eq!(
                     self.event_cubes[[block_idx_y, block_idx_x]].start_t,
                     self.start_t

adder-codec-core/src/codec/compressed/source_model/event_structure/event_cube.rs

@@ -57,11 +57,21 @@ impl EventCube {
         dt_ref: DeltaT,
         num_intervals: usize,
     ) -> Self {
-        let row: [Pixel; BLOCK_SIZE] = vec![Vec::with_capacity(num_intervals); BLOCK_SIZE]
-            .try_into()
-            .unwrap();
-        let square: [[Pixel; BLOCK_SIZE]; BLOCK_SIZE] = vec![row; BLOCK_SIZE].try_into().unwrap();
-        let lists = [square.clone(), square.clone(), square];
+        let new_row = || -> [Pixel; BLOCK_SIZE] {
+            (0..BLOCK_SIZE)
+                .map(|_| Vec::with_capacity(num_intervals))
+                .collect::<Vec<_>>()
+                .try_into()
+                .unwrap()
+        };
+        let new_square = || -> [[Pixel; BLOCK_SIZE]; BLOCK_SIZE] {
+            (0..BLOCK_SIZE)
+                .map(|_| new_row())
+                .collect::<Vec<_>>()
+                .try_into()
+                .unwrap()
+        };
+        let lists = [new_square(), new_square(), new_square()];
 
         Self {
             start_y,

adder-codec-core/src/codec/compressed/stream.rs

@@ -198,7 +198,6 @@ impl<W: Write + std::marker::Send + std::marker::Sync + 'static + 'static + 'sta
             //         }
             //     }
 
-            dbg!("compressing partial last adu");
             let mut temp_stream = BitWriter::endian(Vec::new(), BigEndian);
 
             let parameters = *self.options.crf.get_parameters();
@@ -233,7 +232,6 @@ impl<W: Write + std::marker::Send + std::marker::Sync + 'static + 'static + 'sta
             std::thread::sleep(std::time::Duration::from_secs(1));
         }
 
-        dbg!("All ADUs written.");
         // Kill the written_bytes_tx, so that the Arc only has one reference
         self.written_bytes_tx = None; // This will cause the flush_bytes_queue_worker() thread to
                                       // error out from the receiver, because the communication channel is severed
@@ -400,7 +398,7 @@ impl<R: Read + Seek> ReadCompression<R> for CompressedInput<R> {
                 let adu_bytes = reader.read_to_vec(num_bytes as usize)?;
 
                 // Create a temporary u8 stream to read the arithmetic-coded data from
-                let mut adu_stream = BitReader::endian(Cursor::new(adu_bytes), BigEndian);
+                let adu_stream = BitReader::endian(Cursor::new(adu_bytes), BigEndian);
 
                 // Decompress the Adu
                 adu.decompress(adu_stream);
@@ -428,7 +426,10 @@ impl<R: Read + Seek> ReadCompression<R> for CompressedInput<R> {
         reader: &mut BitReader<R, BigEndian>,
         pos: u64,
     ) -> Result<(), CodecError> {
-        if pos.saturating_sub(self.meta.header_size as u64) % u64::from(self.meta.event_size) != 0 {
+        if !pos
+            .saturating_sub(self.meta.header_size as u64)
+            .is_multiple_of(u64::from(self.meta.event_size))
+        {
             eprintln!("Attempted to seek to bad position in stream: {pos}");
             return Err(CodecError::Seek);
         }
@@ -584,8 +585,6 @@ mod tests {
 
         let output = compressed_output.into_writer().unwrap().into_inner();
         assert!(!output.is_empty());
-        dbg!(counter);
-        dbg!(output.len());
         // Check that the size is less than the raw events
         assert!((output.len() as u32) < counter * 9);
 

adder-codec-core/src/codec/decoder.rs

@@ -327,50 +327,6 @@ mod tests {
         writer.into_inner().unwrap()
     }
 
-    fn setup_encoded_raw_interleaved(codec_version: u8) -> Vec<u8> {
-        let output = Vec::new();
-
-        let bufwriter = BufWriter::new(output);
-        let compression = RawOutput::new(
-            CodecMetadata {
-                codec_version,
-                header_size: 0,
-                time_mode: Default::default(),
-                plane: Default::default(),
-                tps: 0,
-                ref_interval: 255,
-                delta_t_max: 255,
-                event_size: 0,
-                source_camera: Default::default(),
-                adu_interval: 1,
-            },
-            bufwriter,
-        );
-        let mut encoder: Encoder<BufWriter<Vec<u8>>> = Encoder::new_raw(
-            compression,
-            EncoderOptions {
-                event_drop: Default::default(),
-                event_order: EventOrder::Interleaved,
-                crf: Crf::new(
-                    None,
-                    PlaneSize {
-                        width: 100,
-                        height: 100,
-                        channels: 1,
-                    },
-                ),
-            },
-        );
-
-        let event = stock_event();
-        encoder.ingest_event(event).unwrap();
-        let mut writer = encoder.close_writer().unwrap().unwrap();
-
-        writer.flush().unwrap();
-
-        writer.into_inner().unwrap()
-    }
-
     #[cfg(feature = "compression")]
     fn setup_encoded_compressed(codec_version: u8) -> Vec<u8> {
         use crate::codec::CompressedOutput;

adder-codec-core/src/codec/encoder.rs

@@ -452,7 +452,7 @@ mod tests {
     fn compressed() {
         let output = Vec::new();
         let bufwriter = BufWriter::new(output);
-        let (written_bytes_tx, written_bytes_rx) = std::sync::mpsc::channel();
+        let (written_bytes_tx, _written_bytes_rx) = std::sync::mpsc::channel();
 
         let compression = CompressedOutput {
             meta: CodecMetadata {

adder-codec-core/src/codec/raw/stream.rs

@@ -187,8 +187,10 @@ impl<R: Read + Seek> ReadCompression<R> for RawInput<R> {
             match self.bincode.deserialize_from::<_, Event>(&*buffer) {
                 Ok(ev) => ev,
                 Err(e) => {
-                    dbg!(self.meta.event_size);
-                    eprintln!("Error deserializing event: {e}");
+                    eprintln!(
+                        "Error deserializing event (event_size={}): {e}",
+                        self.meta.event_size
+                    );
                     return Err(CodecError::Deserialize);
                 }
             }
@@ -213,7 +215,7 @@ impl<R: Read + Seek> ReadCompression<R> for RawInput<R> {
         reader: &mut BitReader<R, BigEndian>,
         pos: u64,
     ) -> Result<(), CodecError> {
-        if (pos - self.meta.header_size as u64) % u64::from(self.meta.event_size) != 0 {
+        if !(pos - self.meta.header_size as u64).is_multiple_of(u64::from(self.meta.event_size)) {
             eprintln!("Attempted to seek to bad position in stream: {pos}");
             return Err(CodecError::Seek);
         }

adder-codec-core/src/lib.rs

@@ -477,7 +477,6 @@ pub fn open_file_decoder(
         Err(CodecError::WrongMagic) => {
             #[cfg(feature = "compression")]
             {
-                dbg!("Opening as compressed");
                 bufreader = BufReader::new(File::open(file_path)?);
                 let compression = CompressedInput::new(0, 0, 0); // TODO: temporary args. Need to refactor.
                 bitreader = BitReader::endian(bufreader, BigEndian);
@@ -512,8 +511,8 @@ pub struct EventCoordlessRelative {
 }
 
 impl From<EventCoordless> for f64 {
-    fn from(val: EventCoordless) -> Self {
-        panic!("Not implemented")
+    fn from(_val: EventCoordless) -> Self {
+        unreachable!("From<EventCoordless> for f64 is never called; impl exists only to satisfy a trait bound")
     }
 }
 
@@ -538,7 +537,7 @@ impl Add<EventCoordless> for EventCoordless {
     type Output = EventCoordless;
 
     fn add(self, _rhs: EventCoordless) -> EventCoordless {
-        todo!()
+        unreachable!("Add<EventCoordless> for EventCoordless is never called; impl exists only to satisfy num_traits::Zero's Add supertrait bound")
     }
 }
 

adder-codec-rs/benches/framed_to_adder_hd.rs

@@ -13,6 +13,7 @@ use std::path::PathBuf;
 
 use adder_codec_core::TimeMode::DeltaT;
 use adder_codec_rs::transcoder::source::framed::Framed;
+use adder_codec_rs::transcoder::source::video::VideoBuilder;
 use adder_codec_rs::utils::viz::download_file;
 use std::thread::sleep;
 use std::time::Duration;
@@ -30,22 +31,21 @@ fn simul_proc(video_path: &str, scale: f64, thread_count: u8, _chunk_rows: usize
         frame_idx_start: 0,
         show_display: false,
         input_filename: video_path.to_string(),
-        output_events_filename: "".parse().unwrap(),
+        output_events_filename: "".to_string(),
         output_raw_video_filename: manifest_path_str + "/benches/run/bench_out",
         scale,
-        c_thresh_pos: 0,
-        c_thresh_neg: 0,
+        crf: 0,
         thread_count, // Multithreading causes some issues in testing
         time_mode: "delta_t".to_string(),
+        integration_mode: "".to_string(),
     };
     let source: Framed<BufWriter<File>> =
-        Framed::new(args.input_filename, args.color_input, args.scale)
+        Framed::new(args.input_filename.into(), args.color_input, args.scale)
             .unwrap()
             // TODO: chunk_rows back
             .frame_start(args.frame_idx_start)
             .unwrap()
-            .contrast_thresholds(args.c_thresh_pos, args.c_thresh_neg)
-            .show_display(args.show_display)
+            .crf(args.crf)
             .auto_time_parameters(args.ref_time, args.delta_t_max, Some(DeltaT))
             .unwrap();
 
@@ -62,20 +62,13 @@ fn simul_proc(video_path: &str, scale: f64, thread_count: u8, _chunk_rows: usize
     )
     .unwrap();
 
-    simul_processor.run().unwrap();
+    simul_processor.run(args.frame_count_max).unwrap();
     sleep(Duration::from_secs(2));
 
     let output_path = "./benches/run/bench_out";
     fs::remove_file(output_path).unwrap();
 }
 
-fn bench_simul_proc_dark() {
-    let d = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-    let manifest_path_str = d.as_path().to_str().unwrap().to_owned();
-    let path_str = manifest_path_str + "/tests/samples/lake_scaled_hd_crop.mp4";
-    simul_proc(&path_str, 1.0, 1, 4);
-}
-
 fn bench_simul_proc_drop(scale: f64, chunk_rows: usize) {
     let path_str = "./benches/run/drop.mp4";
     let video_url = "https://www.pexels.com/video/2603664/download/";

adder-codec-rs/examples/framed_video_to_adder.rs

@@ -39,7 +39,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
         )?
         .auto_time_parameters(255, 255 * 30, None)?;
 
-    let pool = rayon::ThreadPoolBuilder::new()
+    let _pool = rayon::ThreadPoolBuilder::new()
         .num_threads(current_num_threads())
         .build()
         .unwrap();