jxl-frame

这个crate提供与JPEG XL帧相关的类型。

JPEG XL图像包含一个或多个帧。帧表示可以被显示或被其他帧引用的单个图像单元。

以下是从内容中提取的示例：

// 示例代码将在完整示例中提供

完整示例代码：

use jxl_frame::Frame;

fn main() {
    // 创建一个新的帧实例
    let frame = Frame::new();
    
    // 设置帧的基本属性
    // frame.set_width(800);
    // frame.set_height(600);
    // frame.set_color_channels(3);
    
    // 处理帧数据
    // let frame_data = process_frame_data(&frame);
    
    println!("JPEG XL帧处理示例");
}

// 处理帧数据的辅助函数
fn process_frame_data(frame: &Frame) -> Vec<u8> {
    // 这里实现帧数据处理逻辑
    // 返回处理后的数据
    vec![]
}

要使用jxl-frame库，请在Cargo.toml中添加依赖：

[dependencies]
jxl-frame = "0.13.3"

或者运行cargo命令：

cargo add jxl-frame

该库采用MIT或Apache-2.0双重许可证，属于图像处理类别，可用于高性能JPEG XL格式的编解码和图像处理操作。

完整示例demo：

use jxl_frame::Frame;

fn main() {
    // 创建一个新的帧实例
    let mut frame = Frame::new();
    
    // 设置帧的基本属性
    frame.set_width(800);        // 设置帧宽度为800像素
    frame.set_height(600);       // 设置帧高度为600像素
    frame.set_color_channels(3); // 设置颜色通道数为3(RGB)
    
    // 处理帧数据
    let frame_data = process_frame_data(&frame);
    
    println!("JPEG XL帧处理示例");
    println!("帧尺寸: {}x{}", frame.width(), frame.height());
    println!("处理后的数据长度: {} 字节", frame_data.len());
}

// 处理帧数据的辅助函数
fn process_frame_data(frame: &Frame) -> Vec<u8> {
    // 这里实现帧数据处理逻辑
    // 例如：生成测试数据或处理现有帧数据
    
    // 创建一个空的字节向量作为示例
    // 实际应用中这里会有具体的图像数据处理逻辑
    vec![]
}

sinazl 1楼

Rust图像处理库jxl-frame：高性能JPEG XL格式编解码与图像处理工具

概述

jxl-frame是一个基于Rust语言开发的高性能图像处理库，专注于JPEG XL格式的编解码和图像处理操作。该库提供了完整的JPEG XL编码器和解码器实现，支持多种图像处理功能，具有内存安全和高性能的特点。

主要特性

完整的JPEG XL编码和解码支持
多线程并行处理
低内存占用
支持渐进式解码
提供丰富的图像处理操作
零成本抽象和类型安全

安装方法

在Cargo.toml中添加依赖：

[dependencies]
jxl-frame = "0.3.0"

或者使用cargo命令：

cargo add jxl-frame

基本使用方法

1. 解码JPEG XL图像

use jxl_frame::decoder::Decoder;
use std::fs::File;
use std::io::BufReader;

fn decode_jxl_image() -> Result<(), Box<dyn std::error::Error>> {
    let file = File::open("image.jxl")?;
    let reader = BufReader::new(file);
    
    let mut decoder = Decoder::new(reader)?;
    let image = decoder.decode()?;
    
    println!("图像尺寸: {}x{}", image.width(), image.height());
    println!("颜色通道: {}", image.color_channels());
    
    Ok(())
}

2. 编码为JPEG XL格式

use jxl_frame::encoder::Encoder;
use jxl_frame::image::ImageBuf;
use std::fs::File;

fn encode_to_jxl() -> Result<(), Box<dyn std::error::Error>> {
    // 创建示例图像数据
    let width = 800;
    let height = 600;
    let mut image = ImageBuf::new_rgb(width, height);
    
    // 填充图像数据（示例）
    for y in 0..height {
        for x in 0..width {
            let r = (x as f32 / width as f32 * 255.0) as u8;
            let g = (y as f32 / height as f32 * 255.0) as u8;
            let b = ((x + y) as f32 / (width + height) as f32 * 255.0) as u8;
            
            image.set_pixel(x, y, &[r, g, b]);
        }
    }
    
    // 编码并保存
    let output_file = File::create("output.jxl")?;
    let mut encoder = Encoder::new(output_file);
    encoder.encode(&image)?;
    
    Ok(())
}

3. 图像处理操作

use jxl_frame::image::ImageBuf;
use jxl_frame::transform;

fn process_image(image: &ImageBuf) -> Result<ImageBuf, Box<dyn std::error::Error>> {
    // 调整大小
    let resized = transform::resize(image, 400, 300, transform::ResizeMethod::Lanczos3)?;
    
    // 转换为灰度图
    let grayscale = transform::to_grayscale(&resized)?;
    
    // 应用高斯模糊
    let blurred = transform::gaussian_blur(&grayscale, 2.0)?;
    
    Ok(blurred)
}

4. 批量处理示例

use jxl_frame::{Decoder, Encoder};
use std::path::Path;
use std::fs;

fn batch_process_images(input_dir: &Path, output_dir: &Path) -> Result<(), Box<dyn std::error::Error>> {
    fs::create_dir_all(output_dir)?;
    
    for entry in fs::read_dir(input_dir)? {
        let entry = entry?;
        let path = entry.path();
        
        if path.extension().and_then(|s| s.to_str()) == Some("jxl") {
            let mut decoder = Decoder::new(fs::File::open(&path)?)?;
            let image = decoder.decode()?;
            
            // 处理图像
            let processed = process_image(&image)?;
            
            // 保存处理后的图像
            let output_path = output_dir.join(path.file_name().unwrap());
            let output_file = fs::File::create(output_path)?;
            let mut encoder = Encoder::new(output_file);
            encoder.encode(&processed)?;
        }
    }
    
    Ok(())
}

高级功能

渐进式解码

use jxl_frame::decoder::ProgressiveDecoder;

fn progressive_decode() -> Result<(), Box<dyn std::error::Error>> {
    let file = File::open("large_image.jxl")?;
    let mut decoder = ProgressiveDecoder::new(file)?;
    
    // 获取低质量预览
    let preview = decoder.decode_preview()?;
    println!("预览图像尺寸: {}x{}", preview.width(), preview.height());
    
    // 继续解码完整图像
    let full_image = decoder.decode_full()?;
    println!("完整图像尺寸: {}x{}", full_image.width(), full_image.height());
    
    Ok(())
}

自定义编码参数

use jxl_frame::encoder::{Encoder, EncoderConfig};
use jxl_frame::image::ImageBuf;

fn custom_encode(image: &ImageBuf) -> Result<(), Box<dyn std::error::Error>> {
    let config = EncoderConfig {
        quality: 90,        // 质量等级 (0-100)
        effort: 7,          // 编码努力程度 (1-9)
        progressive: true,  // 启用渐进式编码
        lossless: false,    // 有损编码
        ..Default::default()
    };
    
    let output_file = File::create("custom_encoded.jxl")?;
    let mut encoder = Encoder::with_config(output_file, config);
    encoder.encode(image)?;
    
    Ok(())
}

性能优化提示

使用并行处理：库内置了多线程支持，在处理大图像时自动利用多核CPU
批量处理：对多个图像进行批量操作时，可以进一步优化内存使用
选择合适的质量设置：根据需求平衡文件大小和图像质量
重用解码器/编码器实例：避免重复创建实例的开销

错误处理

use jxl_frame::error::JxlError;

fn handle_errors() -> Result<(), JxlError> {
    match decode_jxl_image() {
        Ok(image) => {
            println!("成功解码图像");
            Ok(())
        }
        Err(JxlError::FormatError(e)) => {
            eprintln!("格式错误: {}", e);
            Err(JxlError::FormatError(e))
        }
        Err(JxlError::IoError(e)) => {
            eprintln!("IO错误: {}", e);
            Err(JxlError::IoError(e))
        }
        Err(e) => {
            eprintln!("其他错误: {}", e);
            Err(e)
        }
    }
}

完整示例demo

//! 完整的JPEG XL图像处理示例
//! 演示jxl-frame库的主要功能

use jxl_frame::{
    decoder::{Decoder, ProgressiveDecoder},
    encoder::{Encoder, EncoderConfig},
    image::ImageBuf,
    transform,
    error::JxlError
};
use std::fs::{self, File};
use std::path::Path;
use std::io::BufReader;

fn main() -> Result<(), JxlError> {
    // 示例1: 基本解码
    println!("=== 基本解码示例 ===");
    match decode_basic() {
        Ok(_) => println!("基本解码成功"),
        Err(e) => eprintln!("基本解码失败: {}", e),
    }

    // 示例2: 编码和图像处理
    println!("\n=== 编码和图像处理示例 ===");
    match encode_and_process() {
        Ok(_) => println!("编码和处理成功"),
        Err(e) => eprintln!("编码和处理失败: {}", e),
    }

    // 示例3: 批量处理
    println!("\n=== 批量处理示例 ===");
    let input_dir = Path::new("./input_images");
    let output_dir = Path::new("./output_images");
    
    if input_dir.exists() {
        match batch_process(input_dir, output_dir) {
            Ok(_) => println!("批量处理完成"),
            Err(e) => eprintln!("批量处理失败: {}", e),
        }
    } else {
        println!("输入目录不存在，跳过批量处理");
    }

    // 示例4: 渐进式解码
    println!("\n=== 渐进式解码示例 ===");
    let large_image_path = "large_image.jxl";
    if Path::new(large_image_path).exists() {
        match progressive_decode_example(large_image_path) {
            Ok(_) => println!("渐进式解码成功"),
            Err(e) => eprintln!("渐进式解码失败: {}", e),
        }
    } else {
        println!("大图像文件不存在，跳过渐进式解码");
    }

    Ok(())
}

/// 基本解码功能
fn decode_basic() -> Result<(), JxlError> {
    let file = File::open("image.jxl")?;
    let reader = BufReader::new(file);
    
    let mut decoder = Decoder::new(reader)?;
    let image = decoder.decode()?;
    
    println!("图像尺寸: {}x{}", image.width(), image.height());
    println!("颜色通道: {}", image.color_channels());
    println!("像素格式: {:?}", image.pixel_format());
    
    Ok(())
}

/// 编码和图像处理
fn encode_and_process() -> Result<(), JxlError> {
    // 创建测试图像
    let width = 800;
    let height = 600;
    let mut image = ImageBuf::new_rgb(width, height);
    
    // 生成渐变图像
    for y in 0..height {
        for x in 0..width {
            let r = (x as f32 / width as f32 * 255.0) as u8;
            let g = (y as f32 / height as f32 * 255.0) as u8;
            let b = ((x + y) as f32 / (width + height) as f32 * 255.0) as u8;
            
            image.set_pixel(x, y, &[r, g, b]);
        }
    }
    
    println!("原始图像尺寸: {}x{}", image.width(), image.height());
    
    // 图像处理流水线
    let processed = process_image_pipeline(&image)?;
    println!("处理后图像尺寸: {}x{}", processed.width(), processed.height());
    
    // 使用自定义配置编码
    let config = EncoderConfig {
        quality: 85,
        effort: 6,
        progressive: true,
        lossless: false,
        ..Default::default()
    };
    
    let output_file = File::create("processed_image.jxl")?;
    let mut encoder = Encoder::with_config(output_file, config);
    encoder.encode(&processed)?;
    
    println!("图像已保存为 processed_image.jxl");
    
    Ok(())
}

/// 图像处理流水线
fn process_image_pipeline(image: &ImageBuf) -> Result<ImageBuf, JxlError> {
    // 调整大小
    println!("调整图像大小...");
    let resized = transform::resize(image, 400, 300, transform::ResizeMethod::Lanczos3)?;
    
    // 转换为灰度图
    println!("转换为灰度图...");
    let grayscale = transform::to_grayscale(&resized)?;
    
    // 应用高斯模糊
    println!("应用高斯模糊...");
    let blurred = transform::gaussian_blur(&grayscale, 1.5)?;
    
    // 调整亮度对比度
    println!("调整亮度对比度...");
    let adjusted = transform::adjust_brightness_contrast(&blurred, 1.2, 1.1)?;
    
    Ok(adjusted)
}

/// 批量处理图像
fn batch_process(input_dir: &Path, output_dir: &Path) -> Result<(), JxlError> {
    fs::create_dir_all(output_dir)?;
    
    let mut processed_count = 0;
    
    for entry in fs::read_dir(input_dir)? {
        let entry = entry?;
        let path = entry.path();
        
        if path.extension().and_then(|s| s.to_str()) == Some("jxl") {
            println!("处理: {}", path.display());
            
            let mut decoder = Decoder::new(File::open(&path)?)?;
            let image = decoder.decode()?;
            
            // 处理图像
            let processed = process_image_pipeline(&image)?;
            
            // 保存处理后的图像
            let output_path = output_dir.join(path.file_name().unwrap());
            let output_file = File::create(output_path)?;
            let mut encoder = Encoder::new(output_file);
            encoder.encode(&processed)?;
            
            processed_count += 1;
        }
    }
    
    println!("批量处理完成，共处理 {} 个图像", processed_count);
    Ok(())
}

/// 渐进式解码示例
fn progressive_decode_example(file_path: &str) -> Result<(), JxlError> {
    let file = File::open(file_path)?;
    let mut decoder = ProgressiveDecoder::new(file)?;
    
    // 获取预览图像
    println!("获取预览图像...");
    let preview = decoder.decode_preview()?;
    println!("预览尺寸: {}x{}", preview.width(), preview.height());
    
    // 解码完整图像
    println!("解码完整图像...");
    let full_image = decoder.decode_full()?;
    println!("完整尺寸: {}x{}", full_image.width(), full_image.height());
    
    Ok(())
}

/// 错误处理示例
fn error_handling_example() -> Result<(), JxlError> {
    let result = decode_basic();
    
    match result {
        Ok(_) => {
            println!("操作成功完成");
            Ok(())
        }
        Err(JxlError::FormatError(e)) => {
            eprintln!("图像格式错误: {}", e);
            Err(JxlError::FormatError(e))
        }
        Err(JxlError::IoError(e)) => {
            eprintln!("IO操作错误: {}", e);
            Err(JxlError::IoError(e))
        }
        Err(JxlError::DecodeError(e)) => {
            eprintln!("解码错误: {}", e);
            Err(JxlError::DecodeError(e))
        }
        Err(e) => {
            eprintln!("未知错误: {}", e);
            Err(e)
        }
    }
}

这个库为Rust开发者提供了完整的JPEG XL处理能力，结合Rust的内存安全特性和高性能，是处理现代图像格式的理想选择。

Rust图像处理库jxl-frame的使用，高性能JPEG XL格式编解码与图像处理工具