nom-exif 2.7.0

Exif/metadata parsing library written in pure Rust, both image (jpeg/heif/heic/jpg/tiff etc.) and video/audio (mov/mp4/3gp/webm/mkv/mka, etc.) files are supported.
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
121
122
123
124
125
126
127
128
129

use std::collections::HashMap;

use nom::{
    bytes::streaming,
    combinator::{cond, fail, map_res},
    error::context,
    multi::many_m_n,
    number::streaming::{be_u16, be_u32},
    IResult,
};

use crate::{bbox::FullBoxHeader, utils::parse_cstr};

use super::{ParseBody, ParseBox};

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct IinfBox {
    pub(crate) header: FullBoxHeader,
    pub(crate) entries: HashMap<String, InfeBox>,
}

impl ParseBody<IinfBox> for IinfBox {
    fn parse_body(remain: &[u8], header: FullBoxHeader) -> IResult<&[u8], IinfBox> {
        let version = header.version;

        let (remain, item_count) = if version > 0 {
            be_u32(remain)?
        } else {
            map_res(be_u16, |x| Ok::<u32, ()>(x as u32))(remain)?
        };

        let (remain, entries) =
            many_m_n(item_count as usize, item_count as usize, InfeBox::parse_box)(remain)?;

        let entries = entries
            .into_iter()
            .map(|e| (e.key().to_owned(), e))
            .collect::<HashMap<_, _>>();

        Ok((remain, IinfBox { header, entries }))
    }
}

impl IinfBox {
    pub fn get_infe(&self, item_type: &'static str) -> Option<&InfeBox> {
        self.entries.get(item_type)
    }
}

/// Info entry box
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct InfeBox {
    pub header: FullBoxHeader,
    pub id: u32,
    pub protection_index: u16,
    pub item_type: Option<String>, // version >= 2
    pub item_name: String,
    content_type: Option<String>,
    content_encoding: Option<String>,
    uri_type: Option<String>,
}

impl ParseBody<InfeBox> for InfeBox {
    #[tracing::instrument(skip_all)]
    fn parse_body<'a>(remain: &'a [u8], header: FullBoxHeader) -> IResult<&'a [u8], InfeBox> {
        let version = header.version;

        let (remain, id) = if version > 2 {
            be_u32(remain)?
        } else {
            map_res(be_u16, |x| Ok::<u32, ()>(x as u32))(remain)?
        };

        let (remain, protection_index) = be_u16(remain)?;

        let (remain, item_type) = cond(
            version >= 2,
            map_res(streaming::take(4_usize), |res: &'a [u8]| {
                String::from_utf8(res.to_vec())
            }),
        )(remain)?;

        // tracing::debug!(?header.box_type, ?item_type, ?version, "Got");

        let (remain, item_name) = parse_cstr(remain).map_err(|e| {
            if e.is_incomplete() {
                context("no enough bytes for infe item name", fail::<_, (), _>)(remain).unwrap_err()
            } else {
                e
            }
        })?;

        let (remain, content_type, content_encoding) =
            if version <= 1 || (version >= 2 && item_type.as_ref().unwrap() == "mime") {
                let (remain, content_type) = parse_cstr(remain)?;
                let (remain, content_encoding) = cond(!remain.is_empty(), parse_cstr)(remain)?;
                (remain, Some(content_type), content_encoding)
            } else {
                (remain, None, None)
            };

        let (remain, uri_type) = if version >= 2 && item_type.as_ref().unwrap() == "uri" {
            let (remain, uri_type) = parse_cstr(remain)?;
            (remain, Some(uri_type))
        } else {
            (remain, None)
        };

        Ok((
            remain,
            InfeBox {
                header,
                id,
                protection_index,
                item_type,
                item_name,
                content_type,
                content_encoding,
                uri_type,
            },
        ))
    }
}

impl InfeBox {
    fn key(&self) -> &String {
        self.item_type.as_ref().unwrap_or(&self.item_name)
    }
}