1use std::borrow::Borrow;
2
3pub(crate) struct SectionPlacement {
4 pub(crate) offset: u64,
5 pub(crate) length: u64,
6 pub(crate) plain_len: u64,
7 pub(crate) crc32: u32,
8}
9
10use crate::{
11 accessions::{INTENSITY_ARRAY, MZ_ARRAY, TIME_ARRAY},
12 ion::{
13 IonResult,
14 encoder::{
15 encode::{
16 CHROM_SUMMARY_SIZE, EncodedArrayAddress, SPEC_SUMMARY_SIZE, WriteOptions,
17 allow_compression_level, check_spectrum_mz_order, check_spectrum_rt_order,
18 encode_single_array, extract_chrom_summary, spec_summary_from_spectrum,
19 window_ranges_for_item, write_array_windows,
20 },
21 scan_stream::ScanStream,
22 utilities::{
23 BlockWriter, DefaultCompressor, SectionChunk,
24 meta_collector::{
25 ArrayPolicy, GroupedSection, LOCAL_LIST_NODE_ID, MetaCollector, MetaGrouper,
26 MzmlListItem, array_type_accession_from_binary_data_array,
27 compress_bytes_if_enabled, serialize_global_meta_with_counts,
28 },
29 output::{SectionStorage, WriteBytes},
30 tables::{
31 ArrayAddressTable, IndexTable, SummaryTable, WindowDirectory, WindowEntry,
32 write_aligned,
33 },
34 },
35 },
36 format::{FILE_TRAILER, HEADER_SIZE},
37 header::Header,
38 meta_groups::METADATA_GROUP_SIZE,
39 utilities::EmitAttributes,
40 windowing::WindowRange,
41 },
42 mzml::structs::{BinaryDataArray, BinaryDataArrayList, Chromatogram, MzML, Spectrum},
43};
44
45fn spec_summary_bytes(spec: &Spectrum) -> [u8; SPEC_SUMMARY_SIZE] {
46 let s = spec_summary_from_spectrum(spec);
47 let mut buf = [0u8; SPEC_SUMMARY_SIZE];
48 buf[0..8].copy_from_slice(&s.rt.to_le_bytes());
49 buf[8..16].copy_from_slice(&s.base_peak_mz.to_le_bytes());
50 buf[16..24].copy_from_slice(&s.selected_ion_mz.to_le_bytes());
51 buf[24..32].copy_from_slice(&s.base_peak_int.to_le_bytes());
52 buf[32..40].copy_from_slice(&s.total_ion_current.to_le_bytes());
53 buf[40] = s.ms_level;
54 buf[41] = s.polarity;
55 buf[42..46].copy_from_slice(&s.position_x.to_le_bytes());
56 buf[46..50].copy_from_slice(&s.position_y.to_le_bytes());
57 buf[50..54].copy_from_slice(&s.position_z.to_le_bytes());
58 buf[54] = s.rt_unit;
59 buf
60}
61
62fn chrom_summary_bytes(chrom: &Chromatogram) -> [u8; CHROM_SUMMARY_SIZE] {
63 let s = extract_chrom_summary(chrom);
64 let mut buf = [0u8; CHROM_SUMMARY_SIZE];
65 buf[0..8].copy_from_slice(&s.lowest_mz.to_le_bytes());
66 buf[8..16].copy_from_slice(&s.highest_mz.to_le_bytes());
67 buf[16..24].copy_from_slice(&s.lowest_wavelength.to_le_bytes());
68 buf[24..32].copy_from_slice(&s.highest_wavelength.to_le_bytes());
69 buf[32..40].copy_from_slice(&s.lowest_ion_mobility.to_le_bytes());
70 buf[40..48].copy_from_slice(&s.highest_ion_mobility.to_le_bytes());
71 buf[48] = s.polarity;
72 buf
73}
74
75struct ArrayWriteState<'a> {
76 addresses: &'a mut ArrayAddressTable,
77 cursor: &'a mut u64,
78 seen: &'a mut Vec<u32>,
79}
80
81impl ArrayWriteState<'_> {
82 fn emit(&mut self, address: &EncodedArrayAddress) -> IonResult<()> {
83 if address.accession != 0 && !self.seen.contains(&address.accession) {
84 self.seen.push(address.accession);
85 }
86 self.addresses.push(
87 address.element_offset,
88 address.element_count,
89 address.block_id,
90 address.accession,
91 address.dtype,
92 address.array_filter,
93 address.encoded_len,
94 address.continues_previous_segment,
95 address.array_cv_code,
96 )?;
97 *self.cursor += 1;
98 Ok(())
99 }
100}
101
102fn write_single_array(
103 bda: &BinaryDataArray,
104 config: WriteOptions,
105 policy: ArrayPolicy,
106 container: &mut BlockWriter<'_, DefaultCompressor>,
107 state: &mut ArrayWriteState<'_>,
108) -> IonResult<()> {
109 let Some(address) = encode_single_array(bda, config, policy, container)? else {
110 return Ok(());
111 };
112 state.emit(&address)?;
113 Ok(())
114}
115
116fn write_windowed_array(
117 bda: &BinaryDataArray,
118 config: WriteOptions,
119 policy: ArrayPolicy,
120 windows: &[WindowRange],
121 container: &mut BlockWriter<'_, DefaultCompressor>,
122 state: &mut ArrayWriteState<'_>,
123) -> IonResult<()> {
124 let addresses = write_array_windows(bda, config, policy, windows, container)?;
125 for address in &addresses {
126 state.emit(address)?;
127 }
128 Ok(())
129}
130
131#[allow(clippy::too_many_arguments)]
132fn encode_arrays_for<T>(
133 item: &T,
134 spectrum_index: u32,
135 config: WriteOptions,
136 policy: ArrayPolicy,
137 windowable: bool,
138 container: &mut BlockWriter<'_, DefaultCompressor>,
139 index: &mut IndexTable,
140 state: &mut ArrayWriteState<'_>,
141 window_directory: &mut WindowDirectory,
142) -> IonResult<()>
143where
144 T: HasArrayList,
145{
146 let address_start = *state.cursor;
147
148 if let Some(list) = item.array_list() {
149 let windows = if windowable {
150 window_ranges_for_item(&list.binary_data_arrays, config, policy, config.mz_window)?
151 } else {
152 None
153 };
154
155 let mut mz_address_start: Option<u64> = None;
156 let mut intensity_address_start: Option<u64> = None;
157
158 for bda in &list.binary_data_arrays {
159 let accession = array_type_accession_from_binary_data_array(bda);
160 let address_start = *state.cursor;
161 match windows.as_ref() {
162 Some(windows) => {
163 write_windowed_array(bda, config, policy, windows, container, state)?
164 }
165 None => write_single_array(bda, config, policy, container, state)?,
166 }
167 if *state.cursor > address_start {
168 if accession == policy.x_array_accession {
169 mz_address_start = Some(address_start);
170 } else if accession == INTENSITY_ARRAY {
171 intensity_address_start = Some(address_start);
172 }
173 }
174 }
175
176 if let (Some(mz_address_start), Some(intensity_address_start)) =
177 (mz_address_start, intensity_address_start)
178 {
179 push_window_entries(
180 window_directory,
181 spectrum_index,
182 mz_address_start,
183 intensity_address_start,
184 windows.as_deref(),
185 );
186 }
187 }
188
189 let address_count = *state.cursor - address_start;
190 index.push(address_start, address_count)?;
191 Ok(())
192}
193
194fn push_window_entries(
195 window_directory: &mut WindowDirectory,
196 spectrum_index: u32,
197 mz_address_start: u64,
198 intensity_address_start: u64,
199 windows: Option<&[WindowRange]>,
200) {
201 match windows {
202 Some(windows) => {
203 for (offset, window) in windows.iter().enumerate() {
204 window_directory.push(
205 window.window_index,
206 WindowEntry {
207 spectrum_index,
208 mz_address: (mz_address_start + offset as u64) as u32,
209 intensity_address: (intensity_address_start + offset as u64) as u32,
210 },
211 );
212 }
213 }
214 None => window_directory.push(
215 0,
216 WindowEntry {
217 spectrum_index,
218 mz_address: mz_address_start as u32,
219 intensity_address: intensity_address_start as u32,
220 },
221 ),
222 }
223}
224
225trait HasArrayList {
226 fn array_list(&self) -> Option<&BinaryDataArrayList>;
227}
228
229impl HasArrayList for Spectrum {
230 fn array_list(&self) -> Option<&BinaryDataArrayList> {
231 self.binary_data_array_list.as_ref()
232 }
233}
234
235impl HasArrayList for Chromatogram {
236 fn array_list(&self) -> Option<&BinaryDataArrayList> {
237 self.binary_data_array_list.as_ref()
238 }
239}
240
241struct ItemStream {
242 summary: SummaryTable,
243 index: IndexTable,
244 addresses: ArrayAddressTable,
245 grouper: MetaGrouper,
246 window_directory: WindowDirectory,
247 windowable: bool,
248 count: usize,
249 address_cursor: u64,
250 seen: Vec<u32>,
251 container_offset: u64,
252 block_count: u64,
253 container_total: u64,
254 directory_crc32: u32,
255}
256
257struct StreamParts {
258 grouped: GroupedSection,
259 summary: SectionChunk,
260 index: SectionChunk,
261 addresses: SectionChunk,
262 window_directory: SectionChunk,
263 count: usize,
264 type_count: usize,
265 container_offset: u64,
266 block_count: u64,
267 container_total: u64,
268 directory_crc32: u32,
269}
270
271impl ItemStream {
272 fn new(
273 summary_hint: usize,
274 summary_size: usize,
275 table_hint: usize,
276 config: WriteOptions,
277 windowable: bool,
278 ) -> IonResult<Self> {
279 let table = |capacity: usize| -> IonResult<SectionChunk> {
280 #[cfg(not(all(target_arch = "wasm32", not(target_os = "wasi"))))]
281 if config.section_storage == SectionStorage::Disk && config.compression_level > 0 {
282 return SectionChunk::spilled(config.compression_level);
283 }
284 Ok(SectionChunk::memory(capacity))
285 };
286 Ok(Self {
287 summary: SummaryTable::new(table(summary_hint * summary_size)?),
288 index: IndexTable::new(table(table_hint * 16)?),
289 addresses: ArrayAddressTable::new(table(table_hint * 64)?),
290 grouper: MetaGrouper::new(
291 METADATA_GROUP_SIZE,
292 config.compression_level,
293 SectionChunk::memory(0),
294 ),
295 window_directory: WindowDirectory::new(),
296 windowable,
297 count: 0,
298 address_cursor: 0,
299 seen: Vec::with_capacity(8),
300 container_offset: 0,
301 block_count: 0,
302 container_total: 0,
303 directory_crc32: 0,
304 })
305 }
306
307 #[allow(clippy::too_many_arguments)]
308 fn add<T, L>(
309 &mut self,
310 item: &T,
311 config: WriteOptions,
312 policy: ArrayPolicy,
313 list_id: u32,
314 list_schema: Option<&L>,
315 collector: &mut MetaCollector,
316 container: &mut BlockWriter<'_, DefaultCompressor>,
317 summary: &[u8],
318 ) -> IonResult<()>
319 where
320 T: HasArrayList + MzmlListItem,
321 L: EmitAttributes,
322 {
323 let mut state = ArrayWriteState {
324 addresses: &mut self.addresses,
325 cursor: &mut self.address_cursor,
326 seen: &mut self.seen,
327 };
328 encode_arrays_for(
329 item,
330 self.count as u32,
331 config,
332 policy,
333 self.windowable,
334 container,
335 &mut self.index,
336 &mut state,
337 &mut self.window_directory,
338 )?;
339 self.summary.push(summary)?;
340 collector.add_item(
341 item,
342 self.count,
343 list_id,
344 list_schema,
345 policy,
346 &mut self.grouper,
347 )?;
348 self.count += 1;
349 Ok(())
350 }
351
352 fn finish(self) -> IonResult<StreamParts> {
353 Ok(StreamParts {
354 grouped: self.grouper.finish()?,
355 summary: self.summary.finish(),
356 index: self.index.finish(),
357 addresses: self.addresses.finish(),
358 window_directory: self.window_directory.finish()?,
359 count: self.count,
360 type_count: self.seen.len(),
361 container_offset: self.container_offset,
362 block_count: self.block_count,
363 container_total: self.container_total,
364 directory_crc32: self.directory_crc32,
365 })
366 }
367}
368
369fn write_chunk(output: &mut dyn WriteBytes, section: SectionChunk) -> IonResult<(u64, u64, u32)> {
370 let bytes = section.into_vec()?;
371 let crc32 = crc32fast::hash(&bytes);
372 let offset = write_aligned(output, &bytes)?;
373 Ok((offset, bytes.len() as u64, crc32))
374}
375
376fn write_chunk_maybe_compressed(
377 output: &mut dyn WriteBytes,
378 section: SectionChunk,
379 compression_level: u8,
380) -> IonResult<(u64, u64, u32)> {
381 #[cfg(not(all(target_arch = "wasm32", not(target_os = "wasi"))))]
382 if section.is_spilled() {
383 return section.copy_into(output);
384 }
385 let raw = section.into_vec()?;
386 if raw.is_empty() {
387 let offset = write_aligned(output, &raw)?;
388 return Ok((offset, 0, crc32fast::hash(&raw)));
389 }
390 let stored = compress_bytes_if_enabled(raw, compression_level);
391 let crc32 = crc32fast::hash(&stored);
392 let offset = write_aligned(output, &stored)?;
393 Ok((offset, stored.len() as u64, crc32))
394}
395
396#[allow(clippy::too_many_arguments)]
397fn write_list<T, L, B, I>(
398 output: &mut dyn WriteBytes,
399 config: WriteOptions,
400 policy: ArrayPolicy,
401 list_id: u32,
402 list_schema: Option<&L>,
403 collector: &mut MetaCollector,
404 stream: &mut ItemStream,
405 items: I,
406 summary_of: fn(&T) -> [u8; SPEC_SUMMARY_SIZE],
407) -> IonResult<()>
408where
409 T: HasArrayList + MzmlListItem,
410 L: EmitAttributes,
411 B: Borrow<T>,
412 I: Iterator<Item = IonResult<B>>,
413{
414 stream.container_offset = write_aligned(output, &[])?;
415 let compressor = config.compression_mode()?;
416 let builder = BlockWriter::new(
417 output,
418 config.block_size,
419 compressor,
420 config.block_packing_id(),
421 );
422 #[cfg(not(all(target_arch = "wasm32", not(target_os = "wasi"))))]
423 let builder = builder.window_major()?;
424 let mut container = if config.parallel {
425 builder
426 } else {
427 builder.force_sequential()
428 };
429
430 let mut last_rt = f64::NEG_INFINITY;
431 let is_spectrum_stream = policy.x_array_accession == MZ_ARRAY;
432 for item in items {
433 let item = item?;
434 let item = item.borrow();
435 if is_spectrum_stream && let Some(list) = item.array_list() {
436 check_spectrum_mz_order(&list.binary_data_arrays, stream.count)?;
437 }
438 let summary = summary_of(item);
439 if is_spectrum_stream {
440 check_spectrum_rt_order(&summary, stream.count, &mut last_rt)?;
441 }
442 stream.add(
443 item,
444 config,
445 policy,
446 list_id,
447 list_schema,
448 collector,
449 &mut container,
450 &summary,
451 )?;
452 }
453
454 let summary = container.finish()?;
455 stream.block_count = summary.block_count as u64;
456 stream.container_total = summary.total_bytes;
457 stream.directory_crc32 = summary.directory_crc32;
458 Ok(())
459}
460
461pub struct IonWriter<'out> {
462 output: &'out mut dyn WriteBytes,
463 config: WriteOptions,
464 collector: MetaCollector,
465 spec_list_id: u32,
466 chrom_list_id: u32,
467 spec_stream: ItemStream,
468 chrom_stream: ItemStream,
469}
470
471impl<'out> IonWriter<'out> {
472 pub fn create(output: &'out mut dyn WriteBytes, config: WriteOptions) -> IonResult<Self> {
473 allow_compression_level(config.compression_level)?;
474 output.write(&[0u8; HEADER_SIZE])?;
475
476 let collector = MetaCollector::new();
477 let spec_list_id = LOCAL_LIST_NODE_ID;
478 let chrom_list_id = LOCAL_LIST_NODE_ID;
479
480 Ok(Self {
481 output,
482 config,
483 collector,
484 spec_list_id,
485 chrom_list_id,
486 spec_stream: ItemStream::new(256, SPEC_SUMMARY_SIZE, 256, config, true)?,
487 chrom_stream: ItemStream::new(32, CHROM_SUMMARY_SIZE, 32, config, false)?,
488 })
489 }
490
491 pub fn write_mzml(&mut self, mzml: &MzML) -> IonResult<()> {
492 let spectra = mzml
493 .run
494 .spectrum_list
495 .as_ref()
496 .map_or(&[][..], |list| &list.spectra);
497 let chroms = mzml
498 .run
499 .chromatogram_list
500 .as_ref()
501 .map_or(&[][..], |list| &list.chromatograms);
502
503 write_list(
504 self.output,
505 self.config,
506 self.config.array_policy(MZ_ARRAY),
507 self.spec_list_id,
508 mzml.run.spectrum_list.as_ref(),
509 &mut self.collector,
510 &mut self.spec_stream,
511 spectra.iter().map(Ok),
512 spec_summary_bytes,
513 )?;
514 write_list(
515 self.output,
516 self.config,
517 self.config.array_policy(TIME_ARRAY),
518 self.chrom_list_id,
519 mzml.run.chromatogram_list.as_ref(),
520 &mut self.collector,
521 &mut self.chrom_stream,
522 chroms.iter().map(Ok),
523 chrom_summary_bytes,
524 )?;
525
526 self.finish_inner(mzml)
527 }
528
529 fn write_reader(&mut self, scans: &mut dyn ScanStream) -> IonResult<()> {
530 let metadata = scans.metadata()?;
531 write_list(
532 self.output,
533 self.config,
534 self.config.array_policy(MZ_ARRAY),
535 self.spec_list_id,
536 metadata.run.spectrum_list.as_ref(),
537 &mut self.collector,
538 &mut self.spec_stream,
539 std::iter::from_fn(|| scans.next_spectrum().transpose()),
540 spec_summary_bytes,
541 )?;
542
543 let metadata = scans.metadata()?;
544 write_list(
545 self.output,
546 self.config,
547 self.config.array_policy(TIME_ARRAY),
548 self.chrom_list_id,
549 metadata.run.chromatogram_list.as_ref(),
550 &mut self.collector,
551 &mut self.chrom_stream,
552 std::iter::from_fn(|| scans.next_chromatogram().transpose()),
553 chrom_summary_bytes,
554 )?;
555
556 let metadata = scans.metadata()?;
557 self.finish_inner(&metadata)
558 }
559
560 pub fn write_stream(&mut self, scans: &mut dyn ScanStream) -> IonResult<()> {
561 self.write_reader(scans)
562 }
563
564 fn write_window_directory(&mut self, bounds: SectionChunk) -> IonResult<SectionPlacement> {
565 let raw = bounds.into_vec()?;
566 let plain_len = raw.len() as u64;
567 if raw.is_empty() {
568 return Ok(SectionPlacement {
569 offset: 0,
570 length: 0,
571 plain_len: 0,
572 crc32: crc32fast::hash(&[]),
573 });
574 }
575 let stored = compress_bytes_if_enabled(raw, self.config.compression_level);
576 let crc32 = crc32fast::hash(&stored);
577 let offset = write_aligned(self.output, &stored)?;
578 let length = stored.len() as u64;
579 Ok(SectionPlacement {
580 offset,
581 length,
582 plain_len,
583 crc32,
584 })
585 }
586
587 fn finish_inner(&mut self, mzml: &MzML) -> IonResult<()> {
588 let (global_meta, global_counts) = self.collector.collect_global_meta(mzml);
589 let raw_global = serialize_global_meta_with_counts(&global_counts, &global_meta)?;
590 let global_uncompressed = raw_global.len() as u64;
591 let global_bytes = compress_bytes_if_enabled(raw_global, self.config.compression_level);
592
593 let spec = std::mem::replace(
594 &mut self.spec_stream,
595 ItemStream::new(256, SPEC_SUMMARY_SIZE, 256, self.config, true)?,
596 )
597 .finish()?;
598 let chrom = std::mem::replace(
599 &mut self.chrom_stream,
600 ItemStream::new(32, CHROM_SUMMARY_SIZE, 32, self.config, false)?,
601 )
602 .finish()?;
603
604 let spec_meta_crc32 = spec.grouped.crc32;
605 let chrom_meta_crc32 = chrom.grouped.crc32;
606 let global_meta_crc32 = crc32fast::hash(&global_bytes);
607
608 let spec_meta_len = spec.grouped.byte_len;
609 let chrom_meta_len = chrom.grouped.byte_len;
610
611 let compression_level = self.config.compression_level;
612
613 let (off_spec_summary, len_spec_summary_stored, spec_summary_crc32) =
614 write_chunk_maybe_compressed(self.output, spec.summary, compression_level)?;
615 let (off_spec_entries, len_spec_entries_stored, spec_entries_crc32) =
616 write_chunk_maybe_compressed(self.output, spec.index, compression_level)?;
617 let (off_spec_array_addresses, len_spec_array_addresses_stored, spec_array_addresses_crc32) =
618 write_chunk_maybe_compressed(self.output, spec.addresses, compression_level)?;
619 let (off_chrom_summary, len_chrom_summary_stored, chrom_summary_crc32) =
620 write_chunk_maybe_compressed(self.output, chrom.summary, compression_level)?;
621 let (off_chrom_entries, len_chrom_entries_stored, chrom_entries_crc32) =
622 write_chunk_maybe_compressed(self.output, chrom.index, compression_level)?;
623 let (
624 off_chrom_array_addresses,
625 len_chrom_array_addresses_stored,
626 chrom_array_addresses_crc32,
627 ) = write_chunk_maybe_compressed(self.output, chrom.addresses, compression_level)?;
628 let off_spec_meta = write_chunk(self.output, spec.grouped.section)?.0;
629 let off_chrom_meta = write_chunk(self.output, chrom.grouped.section)?.0;
630 let off_global_meta = write_aligned(self.output, &global_bytes)?;
631
632 let a1 = self.write_window_directory(spec.window_directory)?;
633 let b1 = self.write_window_directory(chrom.window_directory)?;
634
635 self.output.write(&FILE_TRAILER)?;
636 let total_file_size = self.output.position()?;
637
638 let header = Header {
639 compression_codec: self.config.codec_id(),
640 compression_level: self.config.compression_level,
641 default_array_filter: self.config.array_filter_id(),
642 target_block_uncompressed_bytes: self.config.block_size as u64,
643
644 off_spec_entries,
645 len_spec_entries: len_spec_entries_stored,
646 off_spec_array_addresses,
647 len_spec_array_addresses: len_spec_array_addresses_stored,
648 off_chrom_entries,
649 len_chrom_entries: len_chrom_entries_stored,
650 off_chrom_array_addresses,
651 len_chrom_array_addresses: len_chrom_array_addresses_stored,
652 off_spec_meta,
653 len_spec_meta: spec_meta_len,
654 off_chrom_meta,
655 len_chrom_meta: chrom_meta_len,
656 off_global_meta,
657 len_global_meta: global_bytes.len() as u64,
658 off_spec_container: spec.container_offset,
659 len_spec_container: spec.container_total,
660 off_chrom_container: chrom.container_offset,
661 len_chrom_container: chrom.container_total,
662
663 spec_block_count: spec.block_count,
664 chrom_block_count: chrom.block_count,
665 spectrum_count: spec.count as u64,
666 chrom_count: chrom.count as u64,
667
668 spec_meta_count: spec.grouped.row_count,
669 spec_meta_numeric_count: spec.grouped.numeric_count,
670 spec_meta_string_count: spec.grouped.string_count,
671 chrom_meta_count: chrom.grouped.row_count,
672 chrom_meta_numeric_count: chrom.grouped.numeric_count,
673 chrom_meta_string_count: chrom.grouped.string_count,
674 global_meta_count: global_meta.ref_codes.len() as u64,
675 global_meta_numeric_count: global_meta.numeric_values.len() as u64,
676 global_meta_string_count: global_meta.string_offsets.len() as u64,
677 spec_array_type_count: spec.type_count as u64,
678 chrom_array_type_count: chrom.type_count as u64,
679
680 spec_meta_uncompressed_bytes: spec.grouped.uncompressed_size,
681 chrom_meta_uncompressed_bytes: chrom.grouped.uncompressed_size,
682 global_meta_uncompressed_bytes: global_uncompressed,
683
684 meta_group_size: METADATA_GROUP_SIZE,
685 spec_meta_group_count: spec.grouped.group_count,
686 chrom_meta_group_count: chrom.grouped.group_count,
687
688 off_spec_summary,
689 len_spec_summary: len_spec_summary_stored,
690 off_chrom_summary,
691 len_chrom_summary: len_chrom_summary_stored,
692
693 total_file_size,
694
695 spec_directory_crc32: spec.directory_crc32,
696 chrom_directory_crc32: chrom.directory_crc32,
697
698 off_spec_window_directory: a1.offset,
699 len_spec_window_directory: a1.length,
700 off_chrom_window_directory: b1.offset,
701 len_chrom_window_directory: b1.length,
702 plain_len_spec_window_directory: a1.plain_len,
703 plain_len_chrom_window_directory: b1.plain_len,
704 spec_window_directory_crc32: a1.crc32,
705 chrom_window_directory_crc32: b1.crc32,
706
707 spec_summary_crc32,
708 spec_entries_crc32,
709 spec_array_addresses_crc32,
710 chrom_summary_crc32,
711 chrom_entries_crc32,
712 chrom_array_addresses_crc32,
713 spec_meta_crc32,
714 chrom_meta_crc32,
715 global_meta_crc32,
716 target_mz_window: self.config.mz_window.round() as u32,
717 header_crc32: 0,
718 ..Header::default()
719 };
720
721 let mut header_bytes = [0u8; HEADER_SIZE];
722 header.write(&mut header_bytes);
723 let crc = crc32fast::hash(&header_bytes[0..1020]);
724 header_bytes[1020..1024].copy_from_slice(&crc.to_le_bytes());
725 self.output.patch(0, &header_bytes)
726 }
727}
728
729pub fn write_mzml_to_ion(
730 mzml: &MzML,
731 config: WriteOptions,
732 output: &mut dyn WriteBytes,
733) -> IonResult<()> {
734 allow_compression_level(config.compression_level)?;
735 IonWriter::create(output, config)?.write_mzml(mzml)
736}