Skip to main content

qualia_core_db/medical/dicom_dataset/
parser.rs

1use super::header::{self, header, DatasetError, ParseLimits, TransferSyntax};
2use std::ops::Range;
3#[derive(Debug, Clone, Copy, PartialEq, Eq)]
4pub struct ElementId(pub(super) usize);
5#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6pub struct ItemId(pub(super) usize);
7#[derive(Debug, Clone, Copy, PartialEq, Eq)]
8pub enum ElementKind {
9    Value,
10    Sequence,
11    EncapsulatedPixels,
12}
13#[derive(Debug)]
14pub struct Element {
15    pub tag: u32,
16    pub vr: Option<[u8; 2]>,
17    pub scope: Option<ItemId>,
18    pub kind: ElementKind,
19    pub(super) value: Range<usize>,
20}
21pub(super) struct Item {
22    pub sequence: ElementId,
23    pub value: Range<usize>,
24}
25/// Source-bound cold index. No source value is copied, decoded or reserialized.
26pub struct Part10Dataset<'a> {
27    pub(super) source: &'a [u8],
28    pub(super) elements: Vec<Element>,
29    pub(super) items: Vec<Item>,
30    pub(super) syntax: TransferSyntax,
31    pub(super) transfer_uid: &'a str,
32    pub(super) digest: [u8; 32],
33    pub(super) media_class: Option<&'a str>,
34    pub(super) media_instance: Option<&'a str>,
35}
36#[derive(Clone, Copy)]
37enum Kind {
38    Root,
39    Sequence(ElementId, bool),
40    Item(ItemId),
41}
42#[derive(Clone, Copy)]
43struct Scope {
44    kind: Kind,
45    end: Option<usize>,
46    bound: usize,
47    last: Option<u32>,
48}
49const EMPTY: Scope = Scope {
50    kind: Kind::Root,
51    end: None,
52    bound: 0,
53    last: None,
54};
55fn spend(work: &mut usize) -> Result<(), DatasetError> {
56    *work = work.checked_sub(1).ok_or(DatasetError::WorkLimit)?;
57    Ok(())
58}
59impl<'a> Part10Dataset<'a> {
60    pub fn parse(source: &'a [u8], limits: ParseLimits) -> Result<Self, DatasetError> {
61        if source.len() > limits.max_bytes {
62            return Err(DatasetError::ByteLimit);
63        }
64        if !crate::dicom::is_dicom_part10(source) {
65            return Err(DatasetError::NotPart10);
66        }
67        if limits.max_depth > 64 {
68            return Err(DatasetError::DepthLimit);
69        }
70        let need = limits
71            .max_elements
72            .checked_mul(std::mem::size_of::<Element>())
73            .and_then(|n| {
74                limits
75                    .max_items
76                    .checked_mul(std::mem::size_of::<Item>())
77                    .and_then(|m| n.checked_add(m))
78            })
79            .ok_or(DatasetError::Overflow)?;
80        if need > limits.max_index_bytes {
81            return Err(DatasetError::IndexLimit);
82        }
83        let mut work = limits.max_work;
84        let mut cursor = 132;
85        let mut transfer = None;
86        let mut media_class = None;
87        let mut media_instance = None;
88        let mut last = None;
89        while cursor < source.len() && header::u16le(source, cursor)? == 2 {
90            spend(&mut work)?;
91            let h = header(source, cursor, true, source.len())?;
92            if h.len == u32::MAX || h.len % 2 != 0 {
93                return Err(DatasetError::MalformedHeader);
94            }
95            if last.is_some_and(|v| h.tag <= v) {
96                return Err(DatasetError::Duplicate(h.tag));
97            }
98            last = Some(h.tag);
99            let end = h
100                .value
101                .checked_add(h.len as usize)
102                .ok_or(DatasetError::Overflow)?;
103            let value = source.get(h.value..end).ok_or(DatasetError::Truncated)?;
104            if matches!(h.tag, 0x00020002 | 0x00020003 | 0x00020010) {
105                if h.vr != Some(*b"UI") {
106                    return Err(DatasetError::Invalid(h.tag));
107                }
108                let text = super::query::uid(value, h.tag)?;
109                match h.tag {
110                    0x00020002 => media_class = Some(text),
111                    0x00020003 => media_instance = Some(text),
112                    _ => transfer = Some(text),
113                }
114            }
115            cursor = end;
116        }
117        let transfer_uid = transfer.ok_or(DatasetError::Missing(0x00020010))?;
118        let syntax = match transfer_uid {
119            "1.2.840.10008.1.2" => TransferSyntax::ImplicitLittleEndian,
120            "1.2.840.10008.1.2.1" => TransferSyntax::ExplicitLittleEndian,
121            "1.2.840.10008.1.2.4.50"
122            | "1.2.840.10008.1.2.4.51"
123            | "1.2.840.10008.1.2.4.80"
124            | "1.2.840.10008.1.2.4.81"
125            | "1.2.840.10008.1.2.4.90"
126            | "1.2.840.10008.1.2.4.91"
127            | "1.2.840.10008.1.2.4.110"
128            | "1.2.840.10008.1.2.4.111"
129            | "1.2.840.10008.1.2.4.112"
130            | "1.2.840.10008.1.2.4.201"
131            | "1.2.840.10008.1.2.4.202"
132            | "1.2.840.10008.1.2.4.203"
133            | "1.2.840.10008.1.2.5" => TransferSyntax::EncapsulatedExplicitLittleEndian,
134            _ => return Err(DatasetError::UnsupportedSyntax),
135        };
136        let mut result = Self {
137            source,
138            elements: Vec::new(),
139            items: Vec::new(),
140            syntax,
141            transfer_uid,
142            digest: *blake3::hash(source).as_bytes(),
143            media_class,
144            media_instance,
145        };
146        result
147            .elements
148            .try_reserve_exact(limits.max_elements)
149            .map_err(|_| DatasetError::IndexLimit)?;
150        result
151            .items
152            .try_reserve_exact(limits.max_items)
153            .map_err(|_| DatasetError::IndexLimit)?;
154        let mut stack = [EMPTY; 65];
155        stack[0] = Scope {
156            kind: Kind::Root,
157            end: Some(source.len()),
158            bound: source.len(),
159            last: None,
160        };
161        let mut depth = 0;
162        loop {
163            spend(&mut work)?;
164            let scope = stack[depth];
165            if scope.end == Some(cursor) {
166                if depth == 0 {
167                    break;
168                }
169                match scope.kind {
170                    Kind::Sequence(id, _) => result.elements[id.0].value.end = cursor,
171                    Kind::Item(id) => result.items[id.0].value.end = cursor,
172                    _ => {}
173                }
174                depth -= 1;
175                continue;
176            }
177            if cursor >= scope.bound {
178                return Err(DatasetError::Boundary);
179            }
180            let h = header(
181                source,
182                cursor,
183                syntax != TransferSyntax::ImplicitLittleEndian,
184                scope.bound,
185            )?;
186            if h.tag >> 16 == 0xfffe {
187                match (h.tag, scope.kind) {
188                    (0xfffee000, Kind::Sequence(seq, opaque)) => {
189                        if result.items.len() >= limits.max_items {
190                            return Err(DatasetError::ItemLimit);
191                        }
192                        let end = if h.len == u32::MAX {
193                            None
194                        } else {
195                            Some(
196                                h.value
197                                    .checked_add(h.len as usize)
198                                    .ok_or(DatasetError::Overflow)?,
199                            )
200                        };
201                        if h.len != u32::MAX && h.len % 2 != 0 {
202                            return Err(DatasetError::MalformedHeader);
203                        }
204                        if end.is_some_and(|e| e > scope.bound) {
205                            return Err(DatasetError::Boundary);
206                        }
207                        let id = ItemId(result.items.len());
208                        result.items.push(Item {
209                            sequence: seq,
210                            value: h.value..end.unwrap_or(h.value),
211                        });
212                        if opaque {
213                            let end = end.ok_or(DatasetError::MalformedDelimiter)?;
214                            cursor = end;
215                            continue;
216                        }
217                        if depth + 1 > limits.max_depth {
218                            return Err(DatasetError::DepthLimit);
219                        }
220                        depth += 1;
221                        stack[depth] = Scope {
222                            kind: Kind::Item(id),
223                            end,
224                            bound: end.unwrap_or(scope.bound),
225                            last: None,
226                        };
227                        cursor = h.value;
228                    }
229                    (0xfffee00d, Kind::Item(id)) if scope.end.is_none() && h.len == 0 => {
230                        result.items[id.0].value.end = cursor;
231                        depth -= 1;
232                        cursor = h.value;
233                    }
234                    (0xfffee0dd, Kind::Sequence(id, _)) if scope.end.is_none() && h.len == 0 => {
235                        result.elements[id.0].value.end = cursor;
236                        depth -= 1;
237                        cursor = h.value;
238                    }
239                    _ => return Err(DatasetError::MalformedDelimiter),
240                }
241                continue;
242            }
243            if matches!(scope.kind, Kind::Sequence(..)) {
244                return Err(DatasetError::MalformedDelimiter);
245            }
246            if scope.last == Some(h.tag) {
247                return Err(DatasetError::Duplicate(h.tag));
248            }
249            if scope.last.is_some_and(|v| h.tag < v) {
250                return Err(DatasetError::Order);
251            }
252            stack[depth].last = Some(h.tag);
253            if depth > 0 && matches!(h.tag >> 16, 0 | 2 | 6) {
254                return Err(DatasetError::MalformedHeader);
255            }
256            if result.elements.len() >= limits.max_elements {
257                return Err(DatasetError::ElementLimit);
258            }
259            let undefined = h.len == u32::MAX;
260            let opaque = h.tag == 0x7fe00010 && undefined;
261            if opaque && syntax != TransferSyntax::EncapsulatedExplicitLittleEndian {
262                return Err(DatasetError::Invalid(h.tag));
263            }
264            let sequence =
265                h.vr == Some(*b"SQ") || (h.vr.is_none() && header::implicit_sequence(h.tag));
266            if undefined && !sequence && !opaque {
267                return Err(DatasetError::UnsupportedImplicitSequence);
268            }
269            if !undefined && h.len % 2 != 0 {
270                return Err(DatasetError::MalformedHeader);
271            }
272            let end = if undefined {
273                None
274            } else {
275                Some(
276                    h.value
277                        .checked_add(h.len as usize)
278                        .ok_or(DatasetError::Overflow)?,
279                )
280            };
281            if end.is_some_and(|e| e > scope.bound) {
282                return Err(DatasetError::Boundary);
283            }
284            let id = ElementId(result.elements.len());
285            let parent = match scope.kind {
286                Kind::Item(id) => Some(id),
287                _ => None,
288            };
289            result.elements.push(Element {
290                tag: h.tag,
291                vr: h.vr,
292                scope: parent,
293                kind: if opaque {
294                    ElementKind::EncapsulatedPixels
295                } else if sequence {
296                    ElementKind::Sequence
297                } else {
298                    ElementKind::Value
299                },
300                value: h.value..end.unwrap_or(h.value),
301            });
302            if sequence || opaque {
303                if depth + 1 > limits.max_depth {
304                    return Err(DatasetError::DepthLimit);
305                }
306                depth += 1;
307                stack[depth] = Scope {
308                    kind: Kind::Sequence(id, opaque),
309                    end,
310                    bound: end.unwrap_or(scope.bound),
311                    last: None,
312                };
313                cursor = h.value;
314            } else {
315                cursor = end.ok_or(DatasetError::Boundary)?;
316            }
317        }
318        Ok(result)
319    }
320}