roxify 1.7.5 → 1.8.0

package/native/pool.rs

@@ -0,0 +1,101 @@
+use anyhow::Result;
+use parking_lot::RwLock;
+use std::sync::Arc;
+
+pub struct ReusableBuffer {
+    data: Vec<u8>,
+    capacity: usize,
+}
+
+impl ReusableBuffer {
+    pub fn new(capacity: usize) -> Self {
+        ReusableBuffer {
+            data: vec![0u8; capacity],
+            capacity,
+        }
+    }
+
+    pub fn as_mut_slice(&mut self) -> &mut [u8] {
+        &mut self.data
+    }
+
+    pub fn as_slice(&self) -> &[u8] {
+        &self.data
+    }
+
+    pub fn resize(&mut self, new_size: usize) -> Result<()> {
+        if new_size > self.capacity {
+            return Err(anyhow::anyhow!("Buffer overflow: {} > {}", new_size, self.capacity));
+        }
+        self.data.truncate(new_size);
+        Ok(())
+    }
+
+    pub fn clear(&mut self) {
+        self.data.clear();
+    }
+}
+
+pub struct BufferPool {
+    buffers: Arc<RwLock<Vec<Arc<RwLock<ReusableBuffer>>>>>,
+    default_capacity: usize,
+}
+
+impl BufferPool {
+    pub fn new(pool_size: usize, capacity: usize) -> Self {
+        let mut buffers = Vec::with_capacity(pool_size);
+        for _ in 0..pool_size {
+            buffers.push(Arc::new(RwLock::new(ReusableBuffer::new(capacity))));
+        }
+
+        BufferPool {
+            buffers: Arc::new(RwLock::new(buffers)),
+            default_capacity: capacity,
+        }
+    }
+
+    pub fn acquire(&self) -> Arc<RwLock<ReusableBuffer>> {
+        let mut pool = self.buffers.write();
+        if let Some(buf) = pool.pop() {
+            buf
+        } else {
+            Arc::new(RwLock::new(ReusableBuffer::new(self.default_capacity)))
+        }
+    }
+
+    pub fn release(&self, buf: Arc<RwLock<ReusableBuffer>>) {
+        buf.write().clear();
+        let mut pool = self.buffers.write();
+        if pool.len() < 16 {
+            pool.push(buf);
+        }
+    }
+}
+
+pub struct ZeroCopyBuffer {
+    ptr: *const u8,
+    len: usize,
+    owned: bool,
+}
+
+impl ZeroCopyBuffer {
+    pub fn from_slice(data: &[u8]) -> Self {
+        ZeroCopyBuffer {
+            ptr: data.as_ptr(),
+            len: data.len(),
+            owned: false,
+        }
+    }
+
+    pub fn as_slice(&self) -> &[u8] {
+        unsafe { std::slice::from_raw_parts(self.ptr, self.len) }
+    }
+
+    pub fn len(&self) -> usize {
+        self.len
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.len == 0
+    }
+}

package/native/progress.rs

@@ -0,0 +1,43 @@
+use parking_lot::Mutex;
+use std::sync::Arc;
+
+pub struct ProgressBar {
+    total: u64,
+    current: Arc<Mutex<u64>>,
+    message: Arc<Mutex<String>>,
+}
+
+impl ProgressBar {
+    pub fn new(total: u64) -> Self {
+        Self {
+            total,
+            current: Arc::new(Mutex::new(0)),
+            message: Arc::new(Mutex::new(String::new())),
+        }
+    }
+
+    pub fn inc(&self, delta: u64) {
+        let mut current = self.current.lock();
+        *current += delta;
+    }
+
+    pub fn set(&self, value: u64) {
+        let mut current = self.current.lock();
+        *current = value;
+    }
+
+    pub fn set_message(&self, msg: String) {
+        let mut message = self.message.lock();
+        *message = msg;
+    }
+
+    pub fn get_progress(&self) -> (u64, u64) {
+        let current = *self.current.lock();
+        (current, self.total)
+    }
+
+    pub fn finish(&self) {
+        let mut current = self.current.lock();
+        *current = self.total;
+    }
+}

package/native/rans.rs

@@ -0,0 +1,149 @@
+use anyhow::Result;
+
+const RANS_L: u32 = 1 << 31;
+const RANS_M: u32 = 1 << 16;
+
+#[derive(Clone, Debug)]
+pub struct Symbol {
+    pub start: u32,
+    pub freq: u32,
+    pub scale_bits: u32,
+}
+
+pub struct RansEncoder {
+    state: u32,
+    output: Vec<u8>,
+    symbols: Vec<Symbol>,
+}
+
+impl RansEncoder {
+    pub fn new(symbols: Vec<Symbol>) -> Self {
+        RansEncoder {
+            state: RANS_L,
+            output: Vec::new(),
+            symbols,
+        }
+    }
+
+    pub fn encode(&mut self, symbol_idx: usize) -> Result<()> {
+        if symbol_idx >= self.symbols.len() {
+            return Err(anyhow::anyhow!("Symbol index out of bounds"));
+        }
+
+        let sym = &self.symbols[symbol_idx];
+
+        while self.state >= (sym.freq << 16) {
+            self.output.push((self.state & 0xFF) as u8);
+            self.state >>= 8;
+        }
+
+        let x = ((self.state / sym.freq) << sym.scale_bits) + sym.start;
+        let y = self.state % sym.freq;
+        self.state = x + y;
+
+        Ok(())
+    }
+
+    pub fn finish(mut self) -> Vec<u8> {
+        while self.state > 0 {
+            self.output.push((self.state & 0xFF) as u8);
+            self.state >>= 8;
+        }
+        self.output.reverse();
+        self.output
+    }
+}
+
+pub struct RansDecoder {
+    state: u32,
+    data: Vec<u8>,
+    pos: usize,
+    symbols: Vec<Symbol>,
+}
+
+impl RansDecoder {
+    pub fn new(data: Vec<u8>, symbols: Vec<Symbol>) -> Self {
+        let mut decoder = RansDecoder {
+            state: RANS_L,
+            data,
+            pos: 0,
+            symbols,
+        };
+        decoder.refill();
+        decoder
+    }
+
+    fn refill(&mut self) {
+        while self.state < RANS_L && self.pos < self.data.len() {
+            self.state = (self.state << 8) | (self.data[self.pos] as u32);
+            self.pos += 1;
+        }
+    }
+
+    pub fn decode(&mut self) -> Result<usize> {
+        let x = self.state & 0xFFFF;
+
+        let mut sym_idx = 0;
+        for (i, sym) in self.symbols.iter().enumerate() {
+            if x >= sym.start && x < sym.start + sym.freq {
+                sym_idx = i;
+                break;
+            }
+        }
+
+        let sym = &self.symbols[sym_idx];
+        let q = self.state / sym.freq;
+        let r = self.state % sym.freq;
+
+        self.state = (q << sym.scale_bits) + (r + sym.start);
+        self.refill();
+
+        Ok(sym_idx)
+    }
+
+    pub fn is_finished(&self) -> bool {
+        self.state == RANS_L && self.pos >= self.data.len()
+    }
+}
+
+pub fn build_symbols_from_frequencies(freqs: &[u32]) -> Vec<Symbol> {
+    let total: u32 = freqs.iter().sum();
+    if total == 0 {
+        return Vec::new();
+    }
+
+    let scale_bits = 16 - (total.leading_zeros() - 16);
+    let mut symbols = Vec::new();
+    let mut start = 0u32;
+
+    for freq in freqs {
+        if *freq > 0 {
+            let scaled = ((*freq as u64) << scale_bits) / (total as u64);
+            symbols.push(Symbol {
+                start,
+                freq: *freq,
+                scale_bits,
+            });
+            start += scaled as u32;
+        }
+    }
+
+    symbols
+}
+
+pub fn estimate_entropy(freqs: &[u32]) -> f64 {
+    let total: u32 = freqs.iter().sum();
+    if total == 0 {
+        return 0.0;
+    }
+
+    let total_f = total as f64;
+    freqs
+        .iter()
+        .filter(|&&f| f > 0)
+        .map(|&f| {
+            let p = (f as f64) / total_f;
+            -p * p.log2()
+        })
+        .sum()
+}