aamva 0.1.1

AAMVA DL/ID — PDF417 barcode scan + payload parser (US / Canadian driver's licenses).
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

//! PDF417 barcode detection via the `rxing` crate.
//!
//! Two entry points mirror the Aadhaar QR module:
//! - [`decode_pdf417_from_image_bytes`] — PNG/JPEG bytes.
//! - [`decode_pdf417_from_luma8`] — raw 8-bit grayscale buffer.

use rxing::{BarcodeFormat, DecodeHints};

use super::error::AamvaError;

/// Decodes a PDF417 barcode from PNG/JPEG image bytes and returns the raw
/// text content.
pub fn decode_pdf417_from_image_bytes(bytes: &[u8]) -> Result<String, AamvaError> {
    let luma = image::load_from_memory(bytes)
        .map_err(|e| AamvaError::ImageDecode(e.to_string()))?
        .to_luma8();
    let (width, height) = (luma.width(), luma.height());
    decode_pdf417_from_luma8(width, height, luma.into_raw())
}

/// Decodes a PDF417 barcode from a raw luma8 buffer (`width × height` bytes).
pub fn decode_pdf417_from_luma8(
    width: u32,
    height: u32,
    luma: Vec<u8>,
) -> Result<String, AamvaError> {
    let expected = (width as usize)
        .checked_mul(height as usize)
        .ok_or_else(|| AamvaError::ImageDecode(format!("dimensions {width}x{height} overflow")))?;
    if luma.len() != expected {
        return Err(AamvaError::PdfDecode(format!(
            "luma buffer length {} does not match width*height={}",
            luma.len(),
            expected
        )));
    }
    let mut hints = DecodeHints::default();
    hints.TryHarder = Some(true);
    let result = rxing::helpers::detect_in_luma_with_hints(
        luma,
        width,
        height,
        Some(BarcodeFormat::PDF_417),
        &mut hints,
    )
    .map_err(map_rxing_err)?;
    Ok(result.getText().to_string())
}

fn map_rxing_err(e: rxing::Exceptions) -> AamvaError {
    // Classify by the concrete `rxing::Exceptions` variant rather than by
    // matching substrings of the formatted message.
    match e {
        rxing::Exceptions::NotFoundException(_) => AamvaError::BarcodeNotFound,
        other => AamvaError::PdfDecode(other.to_string()),
    }
}

// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------

#[cfg(test)]
mod tests {
    use super::*;
    use image::{GrayImage, ImageFormat, Luma};
    use rxing::pdf417::PDF417Writer;
    use rxing::{EncodeHints, Writer};
    use std::io::Cursor;

    /// Renders a PDF417 of `text` into a luma8 buffer.
    fn encode_pdf417_to_luma(text: &str, width: i32, height: i32) -> (u32, u32, Vec<u8>) {
        let writer = PDF417Writer::default();
        let matrix = writer
            .encode_with_hints(
                text,
                &BarcodeFormat::PDF_417,
                width,
                height,
                &EncodeHints::default(),
            )
            .expect("PDF417 encode");
        let w = matrix.getWidth();
        let h = matrix.getHeight();
        let mut img = GrayImage::from_pixel(w, h, Luma([255u8]));
        for y in 0..h {
            for x in 0..w {
                if matrix.get(x, y) {
                    img.put_pixel(x, y, Luma([0u8]));
                }
            }
        }
        (w, h, img.into_raw())
    }

    #[test]
    fn roundtrip_simple_text_via_luma8() {
        let original = "HELLO PDF417";
        let (w, h, buf) = encode_pdf417_to_luma(original, 400, 120);
        let decoded = decode_pdf417_from_luma8(w, h, buf).unwrap();
        assert_eq!(decoded, original);
    }

    #[test]
    fn roundtrip_via_png_bytes() {
        let original = "AAMVA-TEST";
        let (w, h, buf) = encode_pdf417_to_luma(original, 400, 120);
        let img = GrayImage::from_raw(w, h, buf).unwrap();
        let mut png_bytes = Cursor::new(Vec::new());
        img.write_to(&mut png_bytes, ImageFormat::Png).unwrap();
        let decoded = decode_pdf417_from_image_bytes(png_bytes.get_ref()).unwrap();
        assert_eq!(decoded, original);
    }

    #[test]
    fn luma_dimensions_mismatch_is_rejected() {
        let err = decode_pdf417_from_luma8(10, 10, vec![0u8; 50]).unwrap_err();
        assert!(matches!(err, AamvaError::PdfDecode(_)));
    }
}