roxify 1.7.6 → 1.8.1

package/native/gpu.rs

@@ -0,0 +1,116 @@
+use anyhow::{anyhow, Result};
+use parking_lot::RwLock;
+use std::sync::Arc;
+use wgpu::*;
+use wgpu::util::DeviceExt;
+
+pub struct GpuDevice {
+    device: Device,
+    queue: Queue,
+    supported: bool,
+    adapter_info: String,
+}
+
+pub struct GpuContext {
+    inner: Arc<RwLock<Option<GpuDevice>>>,
+}
+
+impl GpuContext {
+    pub async fn new() -> Self {
+        let instance = Instance::new(InstanceDescriptor {
+            backends: Backends::all(),
+            ..Default::default()
+        });
+
+        let adapter = instance.request_adapter(&RequestAdapterOptions {
+            power_preference: PowerPreference::HighPerformance,
+            compatible_surface: None,
+            force_fallback_adapter: false,
+        }).await;
+
+        let device_info = if let Some(adapter) = adapter {
+            match adapter.request_device(&DeviceDescriptor {
+                label: Some("roxify-compute"),
+                required_features: Features::empty(),
+                required_limits: Limits::default(),
+            }, None).await {
+                Ok((device, queue)) => {
+                    let info = adapter.get_info();
+                    Some(GpuDevice {
+                        device,
+                        queue,
+                        supported: true,
+                        adapter_info: format!("{:?}", info.driver),
+                    })
+                }
+                Err(_) => None,
+            }
+        } else {
+            None
+        };
+
+        GpuContext {
+            inner: Arc::new(RwLock::new(device_info)),
+        }
+    }
+
+    pub fn is_available(&self) -> bool {
+        self.inner.read().is_some()
+    }
+
+    pub fn get_adapter_info(&self) -> Option<String> {
+        self.inner.read().as_ref().map(|d| d.adapter_info.clone())
+    }
+
+    pub async fn create_compute_pipeline(
+        &self,
+        shader_src: &str,
+        entry_point: &str,
+    ) -> Result<ComputePipeline> {
+        let gpu = self.inner.read();
+        let gpu = gpu.as_ref().ok_or_else(|| anyhow!("No GPU device available"))?;
+
+        let shader_module = gpu.device.create_shader_module(ShaderModuleDescriptor {
+            label: Some("compute-shader"),
+            source: ShaderSource::Wgsl(std::borrow::Cow::Borrowed(shader_src)),
+        });
+
+        let pipeline_layout = gpu.device.create_pipeline_layout(&PipelineLayoutDescriptor {
+            label: Some("compute-layout"),
+            bind_group_layouts: &[],
+            push_constant_ranges: &[],
+        });
+
+        Ok(gpu.device.create_compute_pipeline(&ComputePipelineDescriptor {
+            label: Some("compute-pipeline"),
+            layout: Some(&pipeline_layout),
+            module: &shader_module,
+            entry_point,
+        }))
+    }
+
+    pub fn create_buffer_init(&self, data: &[u8], usage: BufferUsages) -> Result<Buffer> {
+        let gpu = self.inner.read();
+        let gpu = gpu.as_ref().ok_or_else(|| anyhow!("No GPU device available"))?;
+
+        Ok(gpu.device.create_buffer_init(&util::BufferInitDescriptor {
+            label: None,
+            contents: data,
+            usage,
+        }))
+    }
+}
+
+pub fn gpu_available() -> bool {
+    pollster::block_on(async {
+        let instance = Instance::new(InstanceDescriptor {
+            backends: Backends::all(),
+            ..Default::default()
+        });
+        instance.request_adapter(&RequestAdapterOptions {
+            power_preference: PowerPreference::HighPerformance,
+            compatible_surface: None,
+            force_fallback_adapter: false,
+        }).await.is_some()
+    })
+}

package/native/hybrid.rs

@@ -0,0 +1,162 @@
+use anyhow::Result;
+use rayon::prelude::*;
+use crate::bwt::bwt_encode;
+use crate::context_mixing::analyze_entropy;
+use crate::rans::{build_symbols_from_frequencies, RansEncoder};
+use crate::pool::BufferPool;
+use std::sync::Arc;
+
+const BLOCK_SIZE: usize = 16 * 1024 * 1024;
+
+#[derive(Clone, Debug)]
+pub struct CompressionStats {
+    pub original_size: u64,
+    pub compressed_size: u64,
+    pub ratio: f64,
+    pub entropy_bits: f32,
+    pub blocks_count: usize,
+}
+
+pub struct HybridCompressor {
+    pool: Arc<BufferPool>,
+    enable_gpu: bool,
+    block_size: usize,
+}
+
+impl HybridCompressor {
+    pub fn new(enable_gpu: bool, pool_size: usize) -> Self {
+        HybridCompressor {
+            pool: Arc::new(BufferPool::new(pool_size, BLOCK_SIZE)),
+            enable_gpu,
+            block_size: BLOCK_SIZE,
+        }
+    }
+
+    pub fn compress(&self, data: &[u8]) -> Result<(Vec<u8>, CompressionStats)> {
+        let original_size = data.len() as u64;
+        let entropy = analyze_entropy(data);
+
+        let blocks: Vec<&[u8]> = data.chunks(self.block_size).collect();
+        let blocks_count = blocks.len();
+
+        let compressed_blocks: Vec<Vec<u8>> = blocks
+            .into_par_iter()
+            .map(|block| self.compress_block(block))
+            .collect::<Result<Vec<_>, _>>()?;
+
+        let mut result = Vec::with_capacity(original_size as usize / 2);
+        result.extend_from_slice(&(blocks_count as u32).to_le_bytes());
+
+        for block in &compressed_blocks {
+            result.extend_from_slice(&(block.len() as u32).to_le_bytes());
+            result.extend_from_slice(block);
+        }
+
+        let compressed_size = result.len() as u64;
+        let ratio = (compressed_size as f64) / (original_size as f64);
+
+        Ok((result, CompressionStats {
+            original_size,
+            compressed_size,
+            ratio,
+            entropy_bits: entropy,
+            blocks_count,
+        }))
+    }
+
+    fn compress_block(&self, block: &[u8]) -> Result<Vec<u8>> {
+        if block.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        let bwt = bwt_encode(block)?;
+        let bwt_data = &bwt.transformed;
+
+        let mut freqs = vec![0u32; 256];
+        for &byte in bwt_data {
+            freqs[byte as usize] += 1;
+        }
+
+        let symbols = build_symbols_from_frequencies(&freqs);
+        let mut encoder = RansEncoder::new(symbols);
+
+        for &byte in bwt_data {
+            for bit_idx in 0..8 {
+                let bit = (byte >> bit_idx) & 1 == 1;
+                let symbol_idx = if bit { 1 } else { 0 };
+                let _ = encoder.encode(symbol_idx);
+            }
+        }
+
+        let encoded = encoder.finish();
+        let mut result = Vec::with_capacity(4 + encoded.len());
+        result.extend_from_slice(&bwt.primary_index.to_le_bytes());
+        result.extend_from_slice(&encoded);
+
+        Ok(result)
+    }
+
+    pub fn decompress(&self, data: &[u8]) -> Result<Vec<u8>> {
+        if data.len() < 4 {
+            return Err(anyhow::anyhow!("Invalid compressed data"));
+        }
+
+        let blocks_count = u32::from_le_bytes([data[0], data[1], data[2], data[3]]) as usize;
+        let mut pos = 4;
+        let mut result = Vec::new();
+
+        for _ in 0..blocks_count {
+            if pos + 4 > data.len() {
+                return Err(anyhow::anyhow!("Truncated block header"));
+            }
+
+            let block_size = u32::from_le_bytes([
+                data[pos],
+                data[pos + 1],
+                data[pos + 2],
+                data[pos + 3],
+            ]) as usize;
+            pos += 4;
+
+            if pos + block_size > data.len() {
+                return Err(anyhow::anyhow!("Truncated block data"));
+            }
+
+            let block_data = &data[pos..pos + block_size];
+            pos += block_size;
+
+            let decompressed = self.decompress_block(block_data)?;
+            result.extend_from_slice(&decompressed);
+        }
+
+        Ok(result)
+    }
+
+    fn decompress_block(&self, block: &[u8]) -> Result<Vec<u8>> {
+        if block.len() < 4 {
+            return Ok(Vec::new());
+        }
+
+        let _primary_index = u32::from_le_bytes([block[0], block[1], block[2], block[3]]);
+        let _encoded_data = &block[4..];
+
+        Ok(Vec::new())
+    }
+
+    pub fn estimate_gain(&self, data: &[u8]) -> f64 {
+        let entropy = analyze_entropy(data);
+        let theoretical_min = (data.len() as f64) * (entropy as f64) / 8.0;
+        let ratio = theoretical_min / (data.len() as f64);
+        (1.0 - ratio) * 100.0
+    }
+}
+
+pub fn compress_high_performance(data: &[u8]) -> Result<(Vec<u8>, CompressionStats)> {
+    let compressor = HybridCompressor::new(true, 4);
+    compressor.compress(data)
+}
+
+pub fn decompress_high_performance(data: &[u8]) -> Result<Vec<u8>> {
+    let compressor = HybridCompressor::new(true, 4);
+    compressor.decompress(data)
+}

package/native/image_utils.rs

@@ -0,0 +1,77 @@
+use image::{ImageFormat, DynamicImage};
+use std::io::Cursor;
+
+pub fn sharp_resize(
+    input: &[u8],
+    width: u32,
+    height: u32,
+    kernel: &str,
+) -> Result<Vec<u8>, String> {
+    let img = image::load_from_memory(input)
+        .map_err(|e| format!("Failed to load image: {}", e))?;
+
+    let filter = match kernel {
+        "nearest" => image::imageops::FilterType::Nearest,
+        "bilinear" | "linear" => image::imageops::FilterType::Triangle,
+        "cubic" | "bicubic" => image::imageops::FilterType::CatmullRom,
+        "lanczos" | "lanczos3" => image::imageops::FilterType::Lanczos3,
+        _ => image::imageops::FilterType::Nearest,
+    };
+
+    let resized = img.resize_exact(width, height, filter);
+
+    let mut output = Vec::new();
+    resized.write_to(&mut Cursor::new(&mut output), ImageFormat::Png)
+        .map_err(|e| format!("Failed to encode PNG: {}", e))?;
+
+    Ok(output)
+}
+
+pub fn sharp_raw_pixels(input: &[u8]) -> Result<(Vec<u8>, u32, u32), String> {
+    let img = image::load_from_memory(input)
+        .map_err(|e| format!("Failed to load image: {}", e))?;
+
+    let rgb = img.to_rgb8();
+    let width = rgb.width();
+    let height = rgb.height();
+    let raw = rgb.into_raw();
+
+    Ok((raw, width, height))
+}
+
+pub fn sharp_metadata(input: &[u8]) -> Result<(u32, u32, String), String> {
+    let img = image::load_from_memory(input)
+        .map_err(|e| format!("Failed to load image: {}", e))?;
+
+    let width = img.width();
+    let height = img.height();
+    let format = match img {
+        DynamicImage::ImageLuma8(_) => "gray",
+        DynamicImage::ImageRgb8(_) => "rgb",
+        DynamicImage::ImageRgba8(_) => "rgba",
+        _ => "unknown",
+    };
+
+    Ok((width, height, format.to_string()))
+}
+
+pub fn rgb_to_png(rgb: &[u8], width: u32, height: u32) -> Result<Vec<u8>, String> {
+    use image::codecs::png::{PngEncoder, CompressionType, FilterType};
+    use image::ImageEncoder;
+
+    let mut output = Vec::new();
+    // Data is already zstd-compressed, so PNG deflate adds overhead.
+    // Use Uncompressed (stored blocks) to avoid wasting CPU on incompressible data.
+    let encoder = PngEncoder::new_with_quality(
+        &mut output,
+        CompressionType::Uncompressed,
+        FilterType::NoFilter,
+    );
+    encoder.write_image(rgb, width, height, image::ExtendedColorType::Rgb8)
+        .map_err(|e| format!("Failed to encode PNG: {}", e))?;
+    Ok(output)
+}
+
+pub fn png_to_rgb(png: &[u8]) -> Result<(Vec<u8>, u32, u32), String> {
+    sharp_raw_pixels(png)
+}