1 files changed, 26 insertions, 25 deletions
diff --git a/remuxer/src/import/mod.rs b/remuxer/src/import/mod.rs
index 7971c18..4ccbd1c 100644
--- a/remuxer/src/import/mod.rs
+++ b/remuxer/src/import/mod.rs
@@ -4,7 +4,7 @@
     Copyright (C) 2023 metamuffin <metamuffin.org>
 */
 use anyhow::{anyhow, bail, Result};
-use jellycommon::{BlockIndex, ItemInfo, SeekIndex, SourceTrack, SourceTrackKind};
+use jellycommon::{BlockIndex, LocalTrack, SeekIndex, SourceTrack, SourceTrackKind};
 use jellymatroska::{
     block::Block,
     matroska::MatroskaTag,
@@ -14,7 +14,9 @@ use jellymatroska::{
 use log::{debug, error, info, trace, warn};
 use std::{collections::HashMap, fs::File, path::PathBuf};
 
-pub fn import_read(path: &PathBuf, input: &mut EbmlReader, iteminfo: &mut ItemInfo) -> Result<()> {
+pub fn import_read(path: &PathBuf, input: &mut EbmlReader) -> Result<()> {
+    let mut iteminfo = Vec::new();
+    let mut private = Vec::new();
     while let Some(item) = input.next() {
         let item = match item {
             Ok(item) => item,
@@ -43,7 +45,7 @@ pub fn import_read(path: &PathBuf, input: &mut EbmlReader, iteminfo: &mut ItemIn
             MatroskaTag::Segment(_) => {
                 info!("segment start");
                 let mut children = Unflatten::new_with_end(input, item);
-                import_read_segment(path, &mut children, iteminfo)?;
+                import_read_segment(path, &mut children, &mut iteminfo, &mut private)?;
                 info!("segment end");
             }
             _ => debug!("(r) tag ignored: {item:?}"),
@@ -56,8 +58,9 @@ pub fn import_read(path: &PathBuf, input: &mut EbmlReader, iteminfo: &mut ItemIn
 fn import_read_segment(
     path: &PathBuf,
     segment: &mut Unflatten,
-    iteminfo: &mut ItemInfo,
-) -> Result<()> {
+    iteminfo: &mut Vec<SourceTrack>,
+    private: &mut Vec<LocalTrack>,
+) -> Result<Option<f64>> {
     let (mut timestamp_scale, mut duration) = (None, None);
     let mut seek_index = HashMap::new();
 
@@ -142,8 +145,7 @@ fn import_read_segment(
                                     _ => (),
                                 }
                             }
-                            let itrack_index = iteminfo.tracks.len();
-                            let mtrack_index = index.unwrap();
+                            let track_index = index.unwrap();
                             let kind = match kind.ok_or(anyhow!("track type required"))? {
                                 1 => SourceTrackKind::Video {
                                     fps: fps.unwrap_or(0.0), // TODO
@@ -158,19 +160,18 @@ fn import_read_segment(
                                 17 => SourceTrackKind::Subtitles,
                                 _ => bail!("invalid track type"),
                             };
-                            iteminfo.tracks.insert(
-                                itrack_index,
-                                SourceTrack {
-                                    track_number: mtrack_index,
-                                    path: path.to_owned(),
-                                    default_duration,
-                                    codec_private,
-                                    name: name.unwrap_or_else(|| "unnamed".to_string()),
-                                    codec: codec.unwrap(),
-                                    language: language.unwrap_or_else(|| "none".to_string()),
-                                    kind,
-                                },
-                            );
+                            iteminfo.push(SourceTrack {
+                                default_duration,
+                                name: name.unwrap_or_else(|| "unnamed".to_string()),
+                                codec: codec.unwrap(),
+                                language: language.unwrap_or_else(|| "none".to_string()),
+                                kind,
+                            });
+                            private.push(LocalTrack {
+                                track: track_index as usize,
+                                path: path.to_owned(),
+                                codec_private,
+                            })
                         }
                         _ => debug!("(rst) tag ignored: {item:?}"),
                     }
@@ -253,9 +254,9 @@ fn import_read_segment(
             bincode::config::standard(),
         )?;
     }
-    if let Some(duration) = duration {
-        iteminfo.duration =
-            (duration * timestamp_scale.unwrap_or(1_000_000) as f64) / 1_000_000_000_f64;
-    }
-    Ok(())
+    Ok(if let Some(duration) = duration {
+        Some((duration * timestamp_scale.unwrap_or(1_000_000) as f64) / 1_000_000_000_f64)
+    } else {
+        None
+    })
 }