update remuxer for new schema

1 files changed, 38 insertions, 21 deletions

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))