From fc74676f349f2e9de6f7a508d4ba3ff66935a6f8 Mon Sep 17 00:00:00 2001
From: metamuffin <metamuffin@disroot.org>
Date: Thu, 3 Aug 2023 22:35:04 +0200
Subject: dry run works as expected again

---
 remuxer/src/import/mod.rs | 52 ++++++++++++++++++++++-------------------------
 1 file changed, 24 insertions(+), 28 deletions(-)

(limited to 'remuxer')

diff --git a/remuxer/src/import/mod.rs b/remuxer/src/import/mod.rs
index 4c5275e..a5c4e3c 100644
--- a/remuxer/src/import/mod.rs
+++ b/remuxer/src/import/mod.rs
@@ -15,13 +15,18 @@ use jellymatroska::{
 use log::{debug, error, info, warn};
 use std::path::PathBuf;
 
-pub fn import_metadata(
-    path: &PathBuf,
-    input: &mut EbmlReader,
-) -> Result<(Vec<SourceTrack>, Vec<LocalTrack>, f64)> {
-    let mut iteminfo = Vec::new();
-    let mut private = Vec::new();
-    let mut dur = None;
+#[derive(Default)]
+pub struct MatroskaMetadata {
+    pub title: Option<String>,
+    pub description: Option<String>,
+    pub tracks: Vec<SourceTrack>,
+    pub track_sources: Vec<LocalTrack>,
+    pub image: Option<(String, Vec<u8>)>,
+    pub duration: f64,
+}
+
+pub fn import_metadata(input: &mut EbmlReader) -> Result<MatroskaMetadata> {
+    let mut m = None;
     while let Some(item) = input.next() {
         let item = match item {
             Ok(item) => item,
@@ -50,28 +55,19 @@ pub fn import_metadata(
             MatroskaTag::Segment(_) => {
                 info!("segment start");
                 let mut children = Unflatten::new_with_end(input, item);
-                dur = dur.or(import_read_segment(
-                    path,
-                    &mut children,
-                    &mut iteminfo,
-                    &mut private,
-                )?);
+                m = Some(import_read_segment(&mut children)?);
                 info!("segment end");
             }
             _ => debug!("(r) tag ignored: {item:?}"),
         }
     }
 
-    Ok((iteminfo, private, dur.unwrap_or(0.)))
+    Ok(m.ok_or(anyhow!("no segment"))?)
 }
 
-fn import_read_segment(
-    path: &PathBuf,
-    segment: &mut Unflatten,
-    iteminfo: &mut Vec<SourceTrack>,
-    private: &mut Vec<LocalTrack>,
-) -> Result<Option<f64>> {
+fn import_read_segment(segment: &mut Unflatten) -> Result<MatroskaMetadata> {
     let (mut timestamp_scale, mut duration) = (None, None);
+    let mut m = MatroskaMetadata::default();
 
     while let Some(Ok(Unflat { children, item, .. })) = segment.n() {
         match item {
@@ -83,6 +79,7 @@ fn import_read_segment(
                 })) = children.n()
                 {
                     match item {
+                        MatroskaTag::Title(t) => m.title = Some(t),
                         MatroskaTag::TimestampScale(v) => timestamp_scale = Some(v),
                         MatroskaTag::Duration(v) => duration = Some(v),
                         _ => debug!("(rsi) tag ignored: {item:?}"),
@@ -169,16 +166,16 @@ fn import_read_segment(
                                 17 => SourceTrackKind::Subtitles,
                                 _ => bail!("invalid track type"),
                             };
-                            iteminfo.push(SourceTrack {
+                            m.tracks.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 {
+                            m.track_sources.push(LocalTrack {
                                 track: track_index as usize,
-                                path: path.to_owned(),
+                                path: PathBuf::new(),
                                 codec_private,
                             })
                         }
@@ -190,10 +187,9 @@ fn import_read_segment(
             _ => debug!("(rs) tag ignored: {item:?}"),
         };
     }
+    if let Some(duration) = duration {
+        m.duration = (duration * timestamp_scale.unwrap_or(1_000_000) as f64) / 1_000_000_000_f64;
+    }
 
-    Ok(if let Some(duration) = duration {
-        Some((duration * timestamp_scale.unwrap_or(1_000_000) as f64) / 1_000_000_000_f64)
-    } else {
-        None
-    })
+    Ok(m)
 }
-- 
cgit v1.2.3-70-g09d2