non-seekable mkv almost works

1 files changed, 23 insertions, 10 deletions

diff --git a/remuxer/src/import/mod.rs b/remuxer/src/import/mod.rs
index bd22cf5..11970b0 100644
--- a/remuxer/src/import/mod.rs
+++ b/remuxer/src/import/mod.rs
@@ -1,8 +1,7 @@
-use std::collections::HashMap;
-
 use anyhow::{anyhow, bail, Result};
 use jellycommon::{ItemInfo, SourceTrack, SourceTrackKind};
 use jellymatroska::{
+    block::Block,
     matroska::MatroskaTag,
     read::EbmlReader,
     unflatten::{Unflat, Unflatten},
@@ -47,7 +46,7 @@ pub fn import_read(input: &mut EbmlReader, iteminfo: &mut ItemInfo) -> Result<()
 }
 
 fn import_read_segment(children: &mut Unflatten, iteminfo: &mut ItemInfo) -> Result<()> {
-    let mut track_mapping = HashMap::<u64, usize>::new(); // maps matroska track id to item track id
+    // let mut track_mapping = HashMap::<u64, usize>::new(); // maps matroska track id to item track id
     let (mut timestamp_scale, mut duration) = (None, None);
     while let Some(Ok(Unflat { children, item })) = children.next() {
         match item {
@@ -72,13 +71,23 @@ fn import_read_segment(children: &mut Unflatten, iteminfo: &mut ItemInfo) -> Res
                             let mut children = children.unwrap();
                             while let Some(Ok(Unflat { children, item })) = children.next() {
                                 match item {
-                                    MatroskaTag::Block(_) => (),
+                                    MatroskaTag::Block(buf) => {
+                                        let block = Block::parse(&buf)?;
+                                        debug!(
+                                            "block: track={} tso={}",
+                                            block.track, block.timestamp_off
+                                        )
+                                    }
                                     _ => trace!("{item:?}"),
                                 }
                             }
                         }
-                        MatroskaTag::SimpleBlock(_) => {
-                            // debug!("simple");
+                        MatroskaTag::SimpleBlock(buf) => {
+                            let block = Block::parse(&buf)?;
+                            debug!(
+                                "simple block: track={} tso={}",
+                                block.track, block.timestamp_off
+                            )
                         }
                         _ => debug!("(rsc) tag ignored: {item:?}"),
                     }
@@ -118,8 +127,10 @@ fn import_read_segment(children: &mut Unflatten, iteminfo: &mut ItemInfo) -> Res
                                 mut name,
                                 mut fps,
                                 mut bit_depth,
+                                mut codec_private,
                             ) = (
                                 None, None, None, None, None, None, None, None, None, None, None,
+                                None,
                             );
                             while let Some(Ok(Unflat { children, item })) = children.next() {
                                 match item {
@@ -128,6 +139,7 @@ fn import_read_segment(children: &mut Unflatten, iteminfo: &mut ItemInfo) -> Res
                                     MatroskaTag::TrackNumber(v) => index = Some(v),
                                     MatroskaTag::TrackType(v) => kind = Some(v),
                                     MatroskaTag::Name(v) => name = Some(v),
+                                    MatroskaTag::CodecPrivate(v) => codec_private = Some(v),
                                     MatroskaTag::Audio(_) => {
                                         let mut children = children.unwrap();
                                         while let Some(Ok(Unflat { item, .. })) = children.next() {
@@ -157,11 +169,11 @@ fn import_read_segment(children: &mut Unflatten, iteminfo: &mut ItemInfo) -> Res
                                     _ => (),
                                 }
                             }
-                            let itrack_index = iteminfo.tracks.len();
+                            // let itrack_index = iteminfo.tracks.len();
                             let mtrack_index = index.unwrap();
                             let kind = match kind.ok_or(anyhow!("track type required"))? {
                                 1 => SourceTrackKind::Video {
-                                    fps: fps.unwrap_or(f64::NAN), // TODO
+                                    fps: fps.unwrap_or(0.0), // TODO
                                     width: width.unwrap(),
                                     height: height.unwrap(),
                                 },
@@ -173,10 +185,11 @@ fn import_read_segment(children: &mut Unflatten, iteminfo: &mut ItemInfo) -> Res
                                 17 => SourceTrackKind::Subtitles,
                                 _ => bail!("invalid track type"),
                             };
-                            track_mapping.insert(mtrack_index, itrack_index);
+                            // track_mapping.insert(mtrack_index, itrack_index);
                             iteminfo.tracks.insert(
-                                itrack_index,
+                                mtrack_index,
                                 SourceTrack {
+                                    codec_private,
                                     name: name.unwrap_or_else(|| "unnamed".to_string()),
                                     codec: codec.unwrap(),
                                     language: language.unwrap_or_else(|| "none".to_string()),