image-meta 0.1.4

Image meta information loader
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

use std::io::{BufRead, Seek};

use crate::errors::{ImageError, ImageResult};
use crate::types::{Color, Dimensions, Format, ImageMeta};

const SIGNATURE: [u8; 11] = [
    0x23, 0x3f, 0x52, 0x41, 0x44, 0x49, 0x41, 0x4e, 0x43, 0x45, 0x0a,
];

pub fn load<R: ?Sized + BufRead + Seek>(image: &mut R) -> ImageResult<ImageMeta> {
    read_signature(image)?;

    let (dimensions, color) = read_header(image)?;

    Ok(ImageMeta {
        animation_frames: None,
        color,
        dimensions,
        format: Format::Hdr,
    })
}

fn read_signature<R: ?Sized + BufRead + Seek>(image: &mut R) -> ImageResult {
    let mut signature = [0u8; 11];
    image.read_exact(&mut signature)?;
    if SIGNATURE != signature {
        return Err(ImageError::InvalidSignature);
    }
    Ok(())
}

fn read_header<R: ?Sized + BufRead + Seek>(image: &mut R) -> ImageResult<(Dimensions, Color)> {
    use crate::types::ColorMode::*;

    let color = Color {
        mode: Rgb,
        alpha_channel: false,
        resolution: 32,
    };
    while let Some(Ok(line)) = image.lines().next() {
        // Skip empty lines and comments
        if line.starts_with('#') || line.is_empty() {
            continue;
        }

        // Try to parse the line as a key-value pair
        if let Some((key, value)) = line.split_once("=") {
            match key {
                "FORMAT" => match value {
                    "32-bit_rle_rgbe" => {}
                    "32-bit_rle_xyze" => {}
                    _ => {
                        return Err(ImageError::CorruptImage(
                            format!("Unsupported format: {}", value).into(),
                        ));
                    }
                },
                "PRIMARIES" => {}
                _ => {}
            }
        }
        // Else, we have reached the resolution line
        else {
            let mut iter = line.split_whitespace();
            let c1_tag = iter
                .next()
                .ok_or(ImageError::CorruptImage("Error parsing dimension".into()))?;
            let c1_str = iter
                .next()
                .ok_or(ImageError::CorruptImage("Error parsing dimension".into()))?;
            let c2_tag = iter
                .next()
                .ok_or(ImageError::CorruptImage("Error parsing dimension".into()))?;
            let c2_str = iter
                .next()
                .ok_or(ImageError::CorruptImage("Error parsing dimension".into()))?;
            match (c1_tag, c2_tag) {
                ("-Y", "+X") => {
                    // Common orientation (left-right, top-down)
                    // c1_str is height, c2_str is width
                    let height = c1_str.parse::<u32>().map_err(|err| {
                        ImageError::CorruptImage(format!("Error parsing height: {err}").into())
                    })?;
                    let width = c2_str.parse::<u32>().map_err(|err| {
                        ImageError::CorruptImage(format!("Error parsing width: {err}").into())
                    })?;
                    return Ok((Dimensions { width, height }, color));
                }
                _ => return Err(ImageError::Unsupported),
            }
        }
    }
    Err(ImageError::Unsupported)
}