roxify 1.13.7 → 1.13.9

package/native/pool.rs

@@ -1,101 +0,0 @@
-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

@@ -1,142 +0,0 @@
-use parking_lot::Mutex;
-use std::sync::Arc;
-use std::time::Instant;
-
-#[derive(Clone, Debug)]
-pub struct ProgressSnapshot {
-    pub current: u64,
-    pub total: u64,
-    pub percentage: f64,
-    pub elapsed_ms: u64,
-    pub eta_ms: Option<u64>,
-    pub speed_bytes_per_sec: f64,
-    pub step: String,
-}
-
-struct ProgressInner {
-    total: u64,
-    current: u64,
-    step: String,
-    start: Instant,
-}
-
-pub struct ProgressBar {
-    inner: Arc<Mutex<ProgressInner>>,
-    callback: Arc<Mutex<Option<Box<dyn Fn(ProgressSnapshot) + Send>>>>,
-}
-
-impl ProgressBar {
-    pub fn new(total: u64) -> Self {
-        Self {
-            inner: Arc::new(Mutex::new(ProgressInner {
-                total,
-                current: 0,
-                step: String::new(),
-                start: Instant::now(),
-            })),
-            callback: Arc::new(Mutex::new(None)),
-        }
-    }
-
-    pub fn with_callback<F: Fn(ProgressSnapshot) + Send + 'static>(total: u64, cb: F) -> Self {
-        Self {
-            inner: Arc::new(Mutex::new(ProgressInner {
-                total,
-                current: 0,
-                step: String::new(),
-                start: Instant::now(),
-            })),
-            callback: Arc::new(Mutex::new(Some(Box::new(cb)))),
-        }
-    }
-
-    pub fn inc(&self, delta: u64) {
-        let snapshot = {
-            let mut inner = self.inner.lock();
-            inner.current += delta;
-            self.snapshot_inner(&inner)
-        };
-        self.emit(snapshot);
-    }
-
-    pub fn set(&self, value: u64) {
-        let snapshot = {
-            let mut inner = self.inner.lock();
-            inner.current = value;
-            self.snapshot_inner(&inner)
-        };
-        self.emit(snapshot);
-    }
-
-    pub fn set_step(&self, step: &str) {
-        let snapshot = {
-            let mut inner = self.inner.lock();
-            inner.step = step.to_string();
-            self.snapshot_inner(&inner)
-        };
-        self.emit(snapshot);
-    }
-
-    pub fn snapshot(&self) -> ProgressSnapshot {
-        let inner = self.inner.lock();
-        self.snapshot_inner(&inner)
-    }
-
-    fn snapshot_inner(&self, inner: &ProgressInner) -> ProgressSnapshot {
-        let elapsed = inner.start.elapsed();
-        let elapsed_ms = elapsed.as_millis() as u64;
-        let percentage = if inner.total > 0 {
-            (inner.current as f64 / inner.total as f64) * 100.0
-        } else {
-            0.0
-        };
-
-        let elapsed_secs = elapsed.as_secs_f64();
-        let speed = if elapsed_secs > 0.01 {
-            inner.current as f64 / elapsed_secs
-        } else {
-            0.0
-        };
-
-        let eta_ms = if speed > 0.0 && inner.current > 0 && inner.current < inner.total {
-            let remaining = inner.total - inner.current;
-            Some((remaining as f64 / speed * 1000.0) as u64)
-        } else {
-            None
-        };
-
-        ProgressSnapshot {
-            current: inner.current,
-            total: inner.total,
-            percentage,
-            elapsed_ms,
-            eta_ms,
-            speed_bytes_per_sec: speed,
-            step: inner.step.clone(),
-        }
-    }
-
-    fn emit(&self, snapshot: ProgressSnapshot) {
-        if let Some(ref cb) = *self.callback.lock() {
-            cb(snapshot);
-        }
-    }
-
-    pub fn finish(&self) {
-        let snapshot = {
-            let mut inner = self.inner.lock();
-            inner.current = inner.total;
-            self.snapshot_inner(&inner)
-        };
-        self.emit(snapshot);
-    }
-
-    pub fn get_progress(&self) -> (u64, u64) {
-        let inner = self.inner.lock();
-        (inner.current, inner.total)
-    }
-
-    pub fn set_message(&self, msg: String) {
-        self.set_step(&msg);
-    }
-}

package/native/rans.rs

@@ -1,149 +0,0 @@
-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()
-}

package/native/rans_byte.rs

@@ -1,286 +0,0 @@
-use anyhow::Result;
-
-const PROB_BITS: u32 = 12;
-const PROB_SCALE: u32 = 1 << PROB_BITS;
-const RANS_BYTE_L: u32 = 1 << 23;
-
-#[derive(Clone, Debug)]
-pub struct SymbolStats {
-    pub freqs: [u32; 256],
-    pub cum_freqs: [u32; 257],
-}
-
-impl SymbolStats {
-    pub fn from_data(data: &[u8]) -> Self {
-        let mut raw = [0u32; 256];
-        for &b in data {
-            raw[b as usize] += 1;
-        }
-        Self::normalize(raw)
-    }
-
-    fn normalize(raw: [u32; 256]) -> Self {
-        let total: u64 = raw.iter().map(|&f| f as u64).sum();
-        if total == 0 {
-            let mut freqs = [0u32; 256];
-            freqs[0] = PROB_SCALE;
-            let mut cum = [0u32; 257];
-            cum[1] = PROB_SCALE;
-            for i in 2..257 { cum[i] = PROB_SCALE; }
-            return SymbolStats { freqs, cum_freqs: cum };
-        }
-
-        let mut freqs = [0u32; 256];
-        let mut assigned = 0u32;
-        let mut max_idx = 0usize;
-        let mut max_raw = 0u32;
-
-        for i in 0..256 {
-            if raw[i] > 0 {
-                freqs[i] = ((raw[i] as u64 * PROB_SCALE as u64) / total).max(1) as u32;
-                assigned += freqs[i];
-                if raw[i] > max_raw {
-                    max_raw = raw[i];
-                    max_idx = i;
-                }
-            }
-        }
-
-        if assigned > PROB_SCALE {
-            let excess = assigned - PROB_SCALE;
-            freqs[max_idx] = freqs[max_idx].saturating_sub(excess);
-            if freqs[max_idx] == 0 { freqs[max_idx] = 1; }
-        } else if assigned < PROB_SCALE {
-            freqs[max_idx] += PROB_SCALE - assigned;
-        }
-
-        let mut cum_freqs = [0u32; 257];
-        for i in 0..256 {
-            cum_freqs[i + 1] = cum_freqs[i] + freqs[i];
-        }
-
-        SymbolStats { freqs, cum_freqs }
-    }
-
-    pub fn serialize(&self) -> Vec<u8> {
-        let mut out = Vec::with_capacity(512);
-        let mut entries: Vec<(u8, u16)> = Vec::new();
-        for i in 0..256 {
-            if self.freqs[i] > 0 {
-                entries.push((i as u8, self.freqs[i] as u16));
-            }
-        }
-        out.extend_from_slice(&(entries.len() as u16).to_le_bytes());
-        for (sym, freq) in &entries {
-            out.push(*sym);
-            out.extend_from_slice(&freq.to_le_bytes());
-        }
-        out
-    }
-
-    pub fn deserialize(data: &[u8]) -> Result<(Self, usize)> {
-        if data.len() < 2 {
-            return Err(anyhow::anyhow!("Stats too short"));
-        }
-        let count = u16::from_le_bytes([data[0], data[1]]) as usize;
-        let needed = 2 + count * 3;
-        if data.len() < needed {
-            return Err(anyhow::anyhow!("Truncated stats"));
-        }
-
-        let mut freqs = [0u32; 256];
-        let mut pos = 2;
-        for _ in 0..count {
-            let sym = data[pos] as usize;
-            let freq = u16::from_le_bytes([data[pos + 1], data[pos + 2]]) as u32;
-            freqs[sym] = freq;
-            pos += 3;
-        }
-
-        let mut cum_freqs = [0u32; 257];
-        for i in 0..256 {
-            cum_freqs[i + 1] = cum_freqs[i] + freqs[i];
-        }
-
-        Ok((SymbolStats { freqs, cum_freqs }, needed))
-    }
-}
-
-#[inline(always)]
-fn rans_enc_put(state: &mut u32, buf: &mut Vec<u8>, start: u32, freq: u32) {
-    let x_max = ((RANS_BYTE_L >> PROB_BITS) << 8) * freq;
-    let mut x = *state;
-    while x >= x_max {
-        buf.push((x & 0xFF) as u8);
-        x >>= 8;
-    }
-    *state = ((x / freq) << PROB_BITS) + (x % freq) + start;
-}
-
-#[inline(always)]
-fn rans_dec_renorm(state: &mut u32, data: &[u8], pos: &mut usize) {
-    while *state < RANS_BYTE_L && *pos < data.len() {
-        *state = (*state << 8) | (data[*pos] as u32);
-        *pos += 1;
-    }
-}
-
-fn write_state(out: &mut Vec<u8>, state: u32) {
-    out.push((state >> 24) as u8);
-    out.push(((state >> 16) & 0xFF) as u8);
-    out.push(((state >> 8) & 0xFF) as u8);
-    out.push((state & 0xFF) as u8);
-}
-
-fn read_state(data: &[u8], pos: &mut usize) -> u32 {
-    let s = (data[*pos] as u32) << 24
-        | (data[*pos + 1] as u32) << 16
-        | (data[*pos + 2] as u32) << 8
-        | (data[*pos + 3] as u32);
-    *pos += 4;
-    s
-}
-
-pub fn rans_encode_block(data: &[u8], stats: &SymbolStats) -> Vec<u8> {
-    if data.is_empty() {
-        return Vec::new();
-    }
-
-    if data.len() < 8 {
-        return rans_encode_single(data, stats);
-    }
-
-    let mut s0: u32 = RANS_BYTE_L;
-    let mut s1: u32 = RANS_BYTE_L;
-    let mut rev_bytes: Vec<u8> = Vec::with_capacity(data.len() + 32);
-
-    let len = data.len();
-    let even_start = if len % 2 == 0 { len } else { len - 1 };
-
-    if len % 2 != 0 {
-        let sym = data[len - 1] as usize;
-        rans_enc_put(&mut s1, &mut rev_bytes, stats.cum_freqs[sym], stats.freqs[sym]);
-    }
-
-    let mut i = even_start;
-    while i >= 2 {
-        i -= 2;
-        let sym1 = data[i + 1] as usize;
-        rans_enc_put(&mut s1, &mut rev_bytes, stats.cum_freqs[sym1], stats.freqs[sym1]);
-        let sym0 = data[i] as usize;
-        rans_enc_put(&mut s0, &mut rev_bytes, stats.cum_freqs[sym0], stats.freqs[sym0]);
-    }
-
-    let mut output = Vec::with_capacity(9 + rev_bytes.len());
-    output.push(1);
-    write_state(&mut output, s0);
-    write_state(&mut output, s1);
-
-    for &b in rev_bytes.iter().rev() {
-        output.push(b);
-    }
-    output
-}
-
-fn rans_encode_single(data: &[u8], stats: &SymbolStats) -> Vec<u8> {
-    let mut state: u32 = RANS_BYTE_L;
-    let mut rev_bytes: Vec<u8> = Vec::with_capacity(data.len() + 16);
-
-    for &byte in data.iter().rev() {
-        let s = byte as usize;
-        rans_enc_put(&mut state, &mut rev_bytes, stats.cum_freqs[s], stats.freqs[s]);
-    }
-
-    let mut output = Vec::with_capacity(5 + rev_bytes.len());
-    output.push(0);
-    write_state(&mut output, state);
-
-    for &b in rev_bytes.iter().rev() {
-        output.push(b);
-    }
-    output
-}
-
-pub fn rans_decode_block(encoded: &[u8], stats: &SymbolStats, output_len: usize) -> Result<Vec<u8>> {
-    if encoded.is_empty() {
-        return Err(anyhow::anyhow!("Data too short"));
-    }
-
-    let mut cum2sym = [0u8; PROB_SCALE as usize];
-    for s in 0..256usize {
-        let start = stats.cum_freqs[s] as usize;
-        let end = stats.cum_freqs[s + 1] as usize;
-        if end > start {
-            cum2sym[start..end].fill(s as u8);
-        }
-    }
-
-    let mode = encoded[0];
-    let mut pos = 1usize;
-
-    if mode == 1 && output_len >= 8 {
-        return rans_decode_interleaved(encoded, &cum2sym, stats, output_len, &mut pos);
-    }
-
-    if pos + 4 > encoded.len() {
-        return Err(anyhow::anyhow!("Data too short"));
-    }
-    let mut state = read_state(encoded, &mut pos);
-    let mut output = Vec::with_capacity(output_len);
-
-    for _ in 0..output_len {
-        let slot = state & (PROB_SCALE - 1);
-        let sym = cum2sym[slot as usize];
-        output.push(sym);
-
-        let freq = stats.freqs[sym as usize];
-        let start = stats.cum_freqs[sym as usize];
-        state = freq * (state >> PROB_BITS) + slot - start;
-
-        rans_dec_renorm(&mut state, encoded, &mut pos);
-    }
-
-    Ok(output)
-}
-
-fn rans_decode_interleaved(
-    encoded: &[u8],
-    cum2sym: &[u8; PROB_SCALE as usize],
-    stats: &SymbolStats,
-    output_len: usize,
-    pos: &mut usize,
-) -> Result<Vec<u8>> {
-    if *pos + 8 > encoded.len() {
-        return Err(anyhow::anyhow!("Data too short for interleaved"));
-    }
-    let mut s0 = read_state(encoded, pos);
-    let mut s1 = read_state(encoded, pos);
-    let mut output = Vec::with_capacity(output_len);
-
-    let pairs = output_len / 2;
-    for _ in 0..pairs {
-        let slot0 = s0 & (PROB_SCALE - 1);
-        let sym0 = cum2sym[slot0 as usize];
-        output.push(sym0);
-        let freq0 = stats.freqs[sym0 as usize];
-        let start0 = stats.cum_freqs[sym0 as usize];
-        s0 = freq0 * (s0 >> PROB_BITS) + slot0 - start0;
-        rans_dec_renorm(&mut s0, encoded, pos);
-
-        let slot1 = s1 & (PROB_SCALE - 1);
-        let sym1 = cum2sym[slot1 as usize];
-        output.push(sym1);
-        let freq1 = stats.freqs[sym1 as usize];
-        let start1 = stats.cum_freqs[sym1 as usize];
-        s1 = freq1 * (s1 >> PROB_BITS) + slot1 - start1;
-        rans_dec_renorm(&mut s1, encoded, pos);
-    }
-
-    if output_len % 2 != 0 {
-        let slot = s1 & (PROB_SCALE - 1);
-        let sym = cum2sym[slot as usize];
-        output.push(sym);
-    }
-
-    Ok(output)
-}