qualia_core_db/medical/dicom_dataset/
parser.rs1use 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}
25pub 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}