2 files changed, 0 insertions, 143 deletions
diff --git a/remuxer/src/import/mod.rs b/remuxer/src/import/mod.rs
index 5f76623..0ce8b47 100644
--- a/remuxer/src/import/mod.rs
+++ b/remuxer/src/import/mod.rs
@@ -3,8 +3,6 @@
     which is licensed under the GNU Affero General Public License (version 3); see /COPYING.
     Copyright (C) 2023 metamuffin <metamuffin.org>
 */
-pub mod seek_index;
-
 use anyhow::{anyhow, bail, Context, Result};
 use jellycommon::{LocalTrack, SourceTrack, SourceTrackKind};
 use jellymatroska::{
diff --git a/remuxer/src/import/seek_index.rs b/remuxer/src/import/seek_index.rs
deleted file mode 100644
index ca1ca1e..0000000
--- a/remuxer/src/import/seek_index.rs
+++ /dev/null
@@ -1,141 +0,0 @@
-use anyhow::Result;
-use jellycommon::{BlockIndex, SeekIndex};
-use jellymatroska::{
-    block::Block,
-    read::EbmlReader,
-    unflatten::{IterWithPos, Unflat, Unflatten},
-    MatroskaTag,
-};
-use log::{debug, info, trace, warn};
-use std::{collections::BTreeMap, fs::File, path::Path};
-
-pub fn write_all(path: &Path) -> Result<()> {
-    if path.with_extension(&format!("si.1")).exists() {
-        info!("seek index already present");
-        return Ok(());
-    }
-    let seek_index = {
-        let input = File::open(&path).unwrap();
-        let mut input = EbmlReader::new(input);
-        import_seek_index(&mut input)?
-    };
-    for (tn, index) in seek_index {
-        info!("writing index {tn} with {} blocks", index.blocks.len());
-        bincode::encode_into_std_write(
-            index,
-            &mut File::create(path.with_extension(&format!("si.{tn}")))?,
-            bincode::config::standard(),
-        )?;
-    }
-    Ok(())
-}
-
-pub fn import_seek_index(input: &mut EbmlReader) -> Result<BTreeMap<u64, SeekIndex>> {
-    let mut seek_index = BTreeMap::new();
-    while let Some(item) = input.next() {
-        let item = match item {
-            Ok(item) => item,
-            Err(e) => {
-                if !matches!(e, jellymatroska::error::Error::Io(_)) {
-                    warn!("{e}");
-                }
-                break;
-            }
-        };
-        match item {
-            MatroskaTag::Segment(_) => {
-                info!("segment start");
-                let mut children = Unflatten::new_with_end(input, item);
-                import_seek_index_segment(&mut children, &mut seek_index)?;
-                info!("segment end");
-            }
-            _ => debug!("(r) tag ignored: {item:?}"),
-        }
-    }
-    Ok(seek_index)
-}
-
-fn import_seek_index_segment(
-    segment: &mut Unflatten,
-    seek_index: &mut BTreeMap<u64, SeekIndex>,
-) -> Result<()> {
-    while let Some(Ok(Unflat { children, item, .. })) = segment.n() {
-        match item {
-            MatroskaTag::SeekHead(_) => {}
-            MatroskaTag::Info(_) => {}
-            MatroskaTag::Tags(_) => {}
-            MatroskaTag::Cues(_) => {}
-            MatroskaTag::Chapters(_) => {}
-            MatroskaTag::Tracks(_) => {}
-            MatroskaTag::Void(_) => {}
-            MatroskaTag::Cluster(_) => {
-                let mut children = children.unwrap();
-                let mut pts = 0;
-                let mut position = children.position();
-
-                loop {
-                    if let Some(Ok(Unflat { children, item, .. })) = children.n() {
-                        match item {
-                            MatroskaTag::Timestamp(ts) => pts = ts,
-                            MatroskaTag::BlockGroup(_) => {
-                                trace!("group");
-                                let mut children = children.unwrap();
-                                // let position = children.position(); //? TODO where should this point to? cluster or block? // probably block
-                                while let Some(Ok(Unflat {
-                                    children: _,
-                                    item,
-                                    position,
-                                })) = children.n()
-                                {
-                                    match item {
-                                        MatroskaTag::Block(ref buf) => {
-                                            let block = Block::parse(buf)?;
-                                            debug!(
-                                                "block: track={} tso={}",
-                                                block.track, block.timestamp_off
-                                            );
-                                            seek_index
-                                                .entry(block.track)
-                                                .or_insert(SeekIndex { blocks: vec![] })
-                                                .blocks
-                                                .push(BlockIndex {
-                                                    pts: pts + block.timestamp_off as u64,
-                                                    source_off: position,
-                                                    size: block.data.len(),
-                                                });
-                                        }
-                                        _ => trace!("{item:?}"),
-                                    }
-                                }
-                            }
-                            MatroskaTag::SimpleBlock(buf) => {
-                                let block = Block::parse(&buf)?;
-                                trace!(
-                                    "simple block: track={} tso={}",
-                                    block.track,
-                                    block.timestamp_off
-                                );
-                                trace!("{pts} {}", block.timestamp_off);
-                                seek_index
-                                    .entry(block.track)
-                                    .or_insert(SeekIndex { blocks: vec![] })
-                                    .blocks
-                                    .push(BlockIndex {
-                                        pts: (pts as i64 + block.timestamp_off as i64) as u64,
-                                        source_off: position,
-                                        size: block.data.len(),
-                                    });
-                            }
-                            _ => trace!("(rsc) tag ignored: {item:?}"),
-                        }
-                    } else {
-                        break;
-                    }
-                    position = children.position();
-                }
-            }
-            _ => debug!("(rs) tag ignored: {item:?}"),
-        };
-    }
-    Ok(())
-}