foodshare-image

Image processing utilities for format detection, metadata extraction, and smart resizing.

Features

• Format Detection - Identify image format from magic bytes (not file extension)
• Metadata Extraction - Get dimensions without decoding entire image
• Smart Width Calculation - Optimal resize dimensions based on file size
• Image Resizing - Resize images with quality preservation (optional feature)

Installation

Add to your Cargo.toml:

[dependencies]
foodshare-image = "1.3"

# With image processing (adds ~2MB to binary)
foodshare-image = { version = "1.3", features = ["processing"] }

Feature Flags

Usage

Format Detection

Detect image format from magic bytes (first few bytes of file):

use foodshare_image::{detect_format, ImageFormat};

let jpeg_bytes = &[0xFF, 0xD8, 0xFF, 0xE0];
let format = detect_format(jpeg_bytes);
assert_eq!(format, Some(ImageFormat::Jpeg));

let png_bytes = &[0x89, 0x50, 0x4E, 0x47];
let format = detect_format(png_bytes);
assert_eq!(format, Some(ImageFormat::Png));

Supported Formats

Metadata Extraction

Get image dimensions without fully decoding:

use foodshare_image::extract_metadata;

let metadata = extract_metadata(&image_bytes)?;
println!("Size: {}x{}", metadata.width, metadata.height);
println!("Format: {:?}", metadata.format);

Smart Width Calculation

Calculate optimal resize width based on file size tiers:

use foodshare_image::{calculate_target_width, SizeTier};

let file_size = 2_500_000; // 2.5 MB
let original_width = 4000;

let target = calculate_target_width(file_size, original_width);
// Returns optimal width for the size tier

// Size tiers:
// - Tiny: < 100 KB -> no resize
// - Small: 100 KB - 500 KB -> max 1200px
// - Medium: 500 KB - 2 MB -> max 1600px
// - Large: 2 MB - 5 MB -> max 2000px
// - XLarge: > 5 MB -> max 2400px

Image Resizing (requires processing feature)

use foodshare_image::{resize_image, ResizeOptions};

let options = ResizeOptions {
    max_width: 1200,
    max_height: 1200,
    quality: 85,
    preserve_aspect_ratio: true,
};

let resized = resize_image(&image_bytes, options)?;

CLI Tool

The fs-image binary provides command-line access:

# Detect format
fs-image detect image.jpg

# Get metadata
fs-image metadata image.png

# Resize image
fs-image resize input.jpg -o output.jpg --width 1200 --quality 85

Use Cases

Pre-upload Optimization

use foodshare_image::{detect_format, calculate_target_width, ImageFormat};

fn should_resize(bytes: &[u8], file_size: usize) -> Option<u32> {
    let format = detect_format(bytes)?;
    
    // Only resize raster formats
    match format {
        ImageFormat::Jpeg | ImageFormat::Png | ImageFormat::WebP => {
            let metadata = extract_metadata(bytes).ok()?;
            let target = calculate_target_width(file_size, metadata.width);
            
            if target < metadata.width {
                Some(target)
            } else {
                None
            }
        }
        _ => None
    }
}

Format Validation

use foodshare_image::{detect_format, ImageFormat};

fn validate_upload(bytes: &[u8]) -> Result<(), &'static str> {
    match detect_format(bytes) {
        Some(ImageFormat::Jpeg) | Some(ImageFormat::Png) | Some(ImageFormat::WebP) => Ok(()),
        Some(_) => Err("Unsupported image format"),
        None => Err("Not a valid image"),
    }
}

Performance

• Format detection: ~10ns (just reads first few bytes)
• Metadata extraction: ~1µs (reads headers only)
• Full resize: depends on image size

License

MIT License - see LICENSE for details.