Skip to main content

ionic/ion/encoder/
ion_writer.rs

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}