zedbar

A pure Rust implementation of barcode scanning, based on the ZBar bar code reader C library.

This is a port of the ZBar library to Rust, providing barcode detection and decoding capabilities with a type-safe, idiomatic Rust API.

Features

Multiple Barcode Formats: QR Code, EAN-13, EAN-8, UPC-A, UPC-E, ISBN-10, ISBN-13, Code 128, Code 93, Code 39, Codabar, Interleaved 2 of 5, DataBar (RSS), SQCode
Pure Rust: No C dependencies, fully memory-safe implementation
Type-Safe Configuration: Compile-time validated configuration API
Command-line Tool: zedbarimg utility for scanning images from the command line
Position Tracking: Optional tracking of barcode positions in images
Inverted Image Support: Can detect barcodes in inverted images

Installation

cargo add zedbar

Cargo Features

By default, all symbologies are enabled. You can selectively enable only the ones you need to reduce compile time and binary size:

cargo add zedbar --no-default-features --features qrcode,ean

Symbology Features

qrcode - QR Code 2D barcode
sqcode - SQ Code 2D barcode
ean - EAN-8, EAN-13, UPC-A, UPC-E, ISBN-10, ISBN-13
code128 - Code 128
code39 - Code 39
code93 - Code 93
codabar - Codabar
databar - GS1 DataBar (RSS)
i25 - Interleaved 2 of 5

Optional Dependencies

Heavy dependencies (tied to features):

encoding_rs, reed-solomon, rand, rand_chacha - Required for QR code decoding (enabled with qrcode feature)
image - Image format loading (PNG, JPEG, etc.) - needed for tests and the zedbarimg binary
clap - Command-line parsing (needed for the zedbarimg binary)

Note: 1D barcode decoders (EAN, Code39, Code128, etc.) have zero external dependencies!

The default feature enables all symbologies plus optional dependencies:

default = ["qrcode", "sqcode", "ean", "code128", "code39", "code93", "codabar", "databar", "i25", "image", "clap"]

Minimal Library

For the absolute minimal build with zero external dependencies (1D barcodes only):

cargo add zedbar --no-default-features --features ean

For QR codes only (with necessary dependencies):

cargo add zedbar --no-default-features --features qrcode

Note: Disabling a feature at compile-time means that symbology will not be compiled into the binary at all, which is different from disabling it via runtime configuration.

Usage

Library

use zedbar::{Image, Scanner};

// Load and convert image to grayscale
let img = image::open("barcode.png")?;
let gray = img.to_luma8();
let (width, height) = gray.dimensions();

// Create scanner and scan image
let mut img = Image::from_gray(gray.as_raw(), width, height)?;
let mut scanner = Scanner::new();
let symbols = scanner.scan(&mut img);

// Process decoded symbols
for symbol in symbols {
    println!("{:?}: {}", symbol.symbol_type(), symbol.data_string().unwrap_or(""));
}

Locating a Symbol in the Image

Each [Symbol] records the image-coordinate points where it was detected, which lets you draw a box around the decode or crop the source image.

for symbol in symbols {
    // QR codes record the four corners of their bounding rectangle;
    // linear barcodes record per-scan touchpoints.
    for point in symbol.points() {
        println!("  point at ({}, {})", point.x, point.y);
    }

    // Or, the axis-aligned bounding box of all those points:
    if let Some(b) = symbol.bounds() {
        println!("  bounds: {}×{} at ({}, {})", b.width, b.height, b.x, b.y);
    }
}

bounds() returns the AABB of points(), with width and height reported as max - min of the recorded points (the extent between the outermost points), not as a pixel count. Both return empty / None for symbols that did not record any points.

Choosing Symbologies

DecoderConfig::new() starts empty — opt in to each symbology you need:

use zedbar::config::*;
use zedbar::{DecoderConfig, Scanner};

let config = DecoderConfig::new()
    .enable(QrCode)
    .enable(Ean13);

let mut scanner = Scanner::with_config(config);

For exploratory use ("just scan whatever's there"), DecoderConfig::all() or Scanner::new() enables every supported symbology in one call.

Advanced Configuration

use zedbar::config::*;
use zedbar::{DecoderConfig, Scanner};

let config = DecoderConfig::new()
    .enable(QrCode)
    .enable(Ean13)
    .set_length_limits(Code39, 4, 20)  // also enables Code39
    .test_inverted(true)               // Try inverted image if no symbols found
    .retry_undecoded_regions(true)     // Crop+upscale small QR codes automatically
    .scan_density(2, 2);               // Scan every 2nd line (faster)

let mut scanner = Scanner::with_config(config);

The per-symbology setters (set_length_limits, set_checksum, set_uncertainty) auto-enable the symbology they target — if you've already mentioned a symbology by name, it's on.

Small QR Codes in Large Images

When a QR code is too small relative to the image (e.g. a QR code on a scanned page), the scanner reports undecoded finder regions. You can handle these manually, or enable automatic retry:

use zedbar::config::*;
use zedbar::{DecoderConfig, Scanner, Image};

// Option 1: Automatic retry (crop + 4x upscale)
let config = DecoderConfig::new()
    .enable(QrCode)
    .retry_undecoded_regions(true);
let mut scanner = Scanner::with_config(config);
let symbols = scanner.scan(&mut img);

// Option 2: Manual control via finder_region()
let mut scanner = Scanner::new();
let result = scanner.scan(&mut img);
if let Some(region) = result.finder_region() {
    let pad = region.width.max(region.height) / 2;
    let x = region.x.saturating_sub(pad);
    let y = region.y.saturating_sub(pad);
    let w = (region.width + 2 * pad).min(img.width() - x);
    let h = (region.height + 2 * pad).min(img.height() - y);
    if let Some(mut upscaled) = img.crop(x, y, w, h).and_then(|c| c.upscale(4)) {
        let retry = scanner.scan(&mut upscaled);
        // process retry.symbols()...
    }
}

Command-line Tool

# Build the tool
cargo build --release --bin zedbarimg

# Scan an image
cargo run --bin zedbarimg examples/test-qr.png
cargo run --bin zedbarimg examples/test-ean13.png

Testing

cargo test

Benchmarks

Comprehensive benchmarks comparing this library with rqrr, rxing, and the original C zbar library are available:

# Compare with rqrr (default)
cargo bench

# Compare with all libraries (requires optional dependencies)
cargo bench --features bench_zbar_c,bench_rxing

See benches/README.md for detailed benchmark documentation and results.

Credits

Original ZBar Library

This project is based on the ZBar bar code reader library:

Original C implementation: Copyright (C) 2007-2010 Jeff Brown spadix@users.sourceforge.net
QR code decoder components: Copyright (C) 2008-2009 Timothy B. Terriberry (tterribe@xiph.org)
Current C library maintenance: Mauro Carvalho Chehab and contributors

The original ZBar library is licensed under LGPL 2.1 or later.

Rust Port

This Rust implementation preserves the algorithms and structure of the original C library while providing a safe, idiomatic Rust API.

Alternatives

If this library doesn't meet your needs, consider these alternatives:

Rust Libraries

rqrr - Pure Rust QR code reader with a different algorithm. Fast and reliable for QR codes specifically, but only supports QR codes.
bardecoder - Another Rust barcode decoder supporting various 1D formats.
rxing - Rust port of ZXing (Zebra Crossing) library, supports many formats.
quircs - Rust bindings to the quirc QR code library.

C/C++ Libraries (via FFI)

ZBar - The original C library this project is based on. Mature and well-tested.
ZXing - Popular Java library with C++ port available.
ZBar-lite - Lightweight fork of ZBar.

Choosing an Alternative

For QR codes only: Consider rqrr - it's fast, pure Rust, and has a simpler API.
For maximum format support: The original ZBar C library or ZXing are very mature.
For pure Rust with broad format support: This library (zedbar) or rxing.
For C bindings to ZBar: Use zbar-rust which provides FFI bindings to the original C library.

License

LGPL 3.0 or later - See LICENSE for details.

This library is licensed under the GNU Lesser General Public License v3.0 or later, consistent with the original ZBar library's licensing.

zedbar 0.4.1