update remuxer for new schema

2 files changed, 64 insertions, 46 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
+    })
 }
diff --git a/remuxer/src/lib.rs b/remuxer/src/lib.rs
index e531f06..5fc35f8 100644
--- a/remuxer/src/lib.rs
+++ b/remuxer/src/lib.rs
@@ -9,7 +9,7 @@ pub mod trim_writer;
 
 use crate::{segment_extractor::SegmentExtractIter, trim_writer::TrimWriter};
 use anyhow::{anyhow, Context};
-use jellycommon::{BlockIndex, ItemInfo, SeekIndex, SourceTrack, SourceTrackKind};
+use jellycommon::{BlockIndex, ItemPublic, LocalTrack, SeekIndex, SourceTrack, SourceTrackKind};
 use jellymatroska::{
     block::Block,
     read::EbmlReader,
@@ -39,11 +39,12 @@ impl RemuxerContext {
         writer: impl Write + 'static,
         range: Range<usize>,
         path_base: PathBuf,
-        iteminfo: ItemInfo,
+        item: ItemPublic,
+        track_sources: Vec<LocalTrack>,
         selection: Vec<usize>,
         webm: bool,
     ) -> anyhow::Result<()> {
-        info!("remuxing {:?} to have tracks {selection:?}", iteminfo.title);
+        info!("remuxing {:?} to have tracks {selection:?}", item.title);
         let writer = TrimWriter::new(writer, range.clone());
         let mut output = EbmlWriter::new(writer, 0);
 
@@ -52,6 +53,8 @@ impl RemuxerContext {
             reader: EbmlReader,
             mapped: u64,
             index: SeekIndex,
+            source_track_index: usize,
+            codec_private: Option<Vec<u8>>,
             layouting_progress_index: usize,
         }
 
@@ -61,21 +64,21 @@ impl RemuxerContext {
             .iter()
             .enumerate()
             .map(|(index, sel)| {
-                let info = iteminfo
+                let info = item
+                    .media.as_ref()
+                    .unwrap()
                     .tracks
-                    .get(sel)
+                    .get(*sel)
                     .ok_or(anyhow!("track not available"))?
                     .to_owned();
-                let source_path = path_base.join(&info.path);
+                let private = &track_sources[*sel];
+                let source_path = path_base.join(&private.path);
                 let mapped = index as u64 + 1;
-                info!(
-                    "\t- {sel} {source_path:?} ({} => {mapped})",
-                    info.track_number
-                );
+                info!("\t- {sel} {source_path:?} ({} => {mapped})", private.track);
                 info!("\t    {}", info);
                 let file = File::open(&source_path).context("opening source file")?;
                 let mut index =
-                    File::open(source_path.with_extension(format!("si.{}", info.track_number)))
+                    File::open(source_path.with_extension(format!("si.{}", private.track)))
                         .context("opening seek index file")?;
                 let index = bincode::decode_from_std_read::<SeekIndex, _, _>(
                     &mut index,
@@ -88,6 +91,8 @@ impl RemuxerContext {
                     reader,
                     info,
                     mapped,
+                    source_track_index: private.track,
+                    codec_private: private.codec_private.clone(),
                     layouting_progress_index: 0,
                 })
             })
@@ -115,16 +120,16 @@ impl RemuxerContext {
 
         output.write_tag(&MatroskaTag::Info(Master::Collected(vec![
             MatroskaTag::TimestampScale(1_000_000),
-            MatroskaTag::Duration(iteminfo.duration * 1000.0),
-            MatroskaTag::Title(iteminfo.title.clone()),
+            MatroskaTag::Duration(item.media.unwrap().duration * 1000.0),
+            MatroskaTag::Title(item.title.clone()),
             MatroskaTag::MuxingApp("jellyremux".to_string()),
             MatroskaTag::WritingApp("jellything".to_string()),
         ])))?;
         output.write_tag(&MatroskaTag::Tags(Master::Collected(vec![])))?;
 
         let tracks_header = inputs
-            .iter()
-            .map(|rc| track_to_ebml(rc.mapped, &rc.info))
+            .iter_mut()
+            .map(|rc| track_to_ebml(rc.mapped, &rc.info, rc.codec_private.take()))
             .collect();
         output.write_tag(&MatroskaTag::Tracks(Master::Collected(tracks_header)))?;
 
@@ -197,7 +202,10 @@ impl RemuxerContext {
             info!("segment layout computed ({} clusters)", clusters.len());
             clusters
         };
-        info!("(perf) compute segment layout: {:?}", Instant::now() - timing_cp);
+        info!(
+            "(perf) compute segment layout: {:?}",
+            Instant::now() - timing_cp
+        );
         let timing_cp = Instant::now();
 
         let max_cue_size = 4 // cues id
@@ -230,7 +238,9 @@ impl RemuxerContext {
         let first_cluster_offset_predict = max_cue_size + output.position();
 
         // make the cluster position relative to the segment start as they should
-        segment_layout.iter_mut().for_each(|e| e.position += first_cluster_offset_predict - segment_offset);
+        segment_layout
+            .iter_mut()
+            .for_each(|e| e.position += first_cluster_offset_predict - segment_offset);
 
         output.write_tag(&MatroskaTag::Cues(Master::Collected(
             segment_layout
@@ -265,7 +275,9 @@ impl RemuxerContext {
 
         if skip != 0 {
             info!("skipping {skip} clusters");
-            output.seek(SeekFrom::Start((segment_layout[skip].position + segment_offset) as u64))?;
+            output.seek(SeekFrom::Start(
+                (segment_layout[skip].position + segment_offset) as u64,
+            ))?;
         }
 
         struct ReaderD<'a> {
@@ -284,7 +296,8 @@ impl RemuxerContext {
                         MatroskaTag::Cluster(Master::Start),
                     )
                     .context("seeking in input")?;
-                let mut stream = SegmentExtractIter::new(&mut inp.reader, inp.info.track_number);
+                let mut stream =
+                    SegmentExtractIter::new(&mut inp.reader, inp.source_track_index as u64);
 
                 Ok(ReaderD {
                     mapped: inp.mapped,
@@ -333,7 +346,11 @@ impl RemuxerContext {
     }
 }
 
-pub fn track_to_ebml(number: u64, track: &SourceTrack) -> MatroskaTag {
+pub fn track_to_ebml(
+    number: u64,
+    track: &SourceTrack,
+    codec_private: Option<Vec<u8>>,
+) -> MatroskaTag {
     let mut els = vec![
         MatroskaTag::TrackNumber(number),
         MatroskaTag::TrackUID(number),
@@ -372,7 +389,7 @@ pub fn track_to_ebml(number: u64, track: &SourceTrack) -> MatroskaTag {
             els.push(MatroskaTag::TrackType(19));
         }
     }
-    if let Some(d) = &track.codec_private {
+    if let Some(d) = &codec_private {
         els.push(MatroskaTag::CodecPrivate(d.clone()));
     }
     MatroskaTag::TrackEntry(Master::Collected(els))