correctly discard added clusters after transcode

3 files changed, 19 insertions, 19 deletions

diff --git a/remuxer/src/demuxers/matroska.rs b/remuxer/src/demuxers/matroska.rs
index be4eddc..7564797 100644
--- a/remuxer/src/demuxers/matroska.rs
+++ b/remuxer/src/demuxers/matroska.rs
@@ -6,7 +6,7 @@
 
 use crate::demuxers::{Demuxer, DemuxerNew, ReadSeek};
 use anyhow::{Context, Result, anyhow, bail};
-use log::debug;
+use log::{debug, trace};
 use std::io::{BufReader, ErrorKind, Read, Seek, SeekFrom};
 use winter_ebml::{Ebml, EbmlHeader, VintReadExt, read_vint_slice};
 use winter_matroska::{
@@ -94,7 +94,7 @@ impl MatroskaDemuxer {
         let mut raw = vec![0u8; size as usize];
         self.reader.read_exact(&mut raw)?;
         let seek_head = SeekHead::read(&raw).context("parsing seek head")?;
-        debug!("parsed {seek_head:#?}");
+        trace!("parsed {seek_head:#?}");
         self.seek_head = Some(seek_head);
         Ok(self.seek_head.as_ref())
     }
@@ -103,9 +103,9 @@ impl MatroskaDemuxer {
     /// Returns the absolute offset of the element start and size of the content.
     pub fn seek_to_segment_tag(&mut self, search_tag: u64) -> Result<Option<(u64, u64)>> {
         if let Some(seek_head) = self.seek_head()?
-            && !search_tag == Segment::TAG_CLUSTERS
+            && search_tag != Segment::TAG_CLUSTERS
         {
-            debug!("using seek head");
+            trace!("using seek head");
             let Some(segment_position) = seek_head
                 .seeks
                 .iter()
@@ -125,7 +125,7 @@ impl MatroskaDemuxer {
             }
             Ok(Some((absolute_offset, size)))
         } else {
-            debug!("using search");
+            trace!("using search");
             self.seek_segment_start()?;
             loop {
                 let pos = self.reader.stream_position()?;
diff --git a/remuxer/src/muxers/mp4.rs b/remuxer/src/muxers/mp4.rs
index 72bec3e..4fcefe5 100644
--- a/remuxer/src/muxers/mp4.rs
+++ b/remuxer/src/muxers/mp4.rs
@@ -6,6 +6,7 @@
 
 use crate::muxers::FragmentMuxer;
 use anyhow::Result;
+use log::debug;
 use std::sync::Mutex;
 use winter_matroska::{Segment, TrackType};
 use winter_mp4::*;
@@ -128,30 +129,27 @@ impl FragmentMuxer for MP4FragmentMuxer {
     fn write_frag(out: &mut Vec<u8>, segment: Segment, index: usize, end_pts: u64) -> Result<()> {
         let mut out = BoxW::new(out);
 
-        let start_pts = (segment.clusters[0].timestamp as i64
-            + segment.clusters[0]
-                .simple_blocks
-                .first()
-                .map(|b| b.timestamp_off)
-                .unwrap_or_else(|| segment.clusters[0].block_groups[0].block.timestamp_off)
-                as i64)
-            * segment.info.timestamp_scale as i64;
+        let start_pts =
+            (segment.clusters[0].timestamp as i64) * segment.info.timestamp_scale as i64;
 
         let num_samples = segment
             .clusters
             .iter()
             .map(|c| c.simple_blocks.len())
             .sum::<usize>();
+
         let dts_delta = ((end_pts - start_pts as u64) / num_samples as u64) as u32;
 
         let mut mdat = Vec::new();
         let mut samples = Vec::new();
         let mut dts = 0;
+        let mut max_cts_offset = 0;
         for cluster in segment.clusters {
             for block in cluster.simple_blocks {
                 let ts = (cluster.timestamp as i64 + block.timestamp_off as i64)
                     * segment.info.timestamp_scale as i64;
                 let pts_off = (ts - start_pts) - dts;
+                max_cts_offset = max_cts_offset.max(pts_off.abs());
                 samples.push(TrackRunSample {
                     composition_time_offset: pts_off.try_into().expect("cts_offset overflow"),
                     duration: dts_delta,
@@ -162,6 +160,10 @@ impl FragmentMuxer for MP4FragmentMuxer {
                 dts += dts_delta as i64;
             }
         }
+        debug!(
+            "max composition_time_offset = {:.03}ms",
+            max_cts_offset as f32 / 1000_000.
+        );
 
         out.write(SegmentType {
             major_brand: *b"msdh",
diff --git a/transcoder/src/fragment.rs b/transcoder/src/fragment.rs
index 2ff36a7..f9ab72d 100644
--- a/transcoder/src/fragment.rs
+++ b/transcoder/src/fragment.rs
@@ -112,12 +112,10 @@ pub fn transcode(
     let tags = demuxer.tags()?;
     let mut clusters = Vec::new();
     while let Some((_, cluster)) = demuxer.read_cluster()? {
-        clusters.push(cluster);
-    }
-
-    //? Remove extra kf hack
-    if clusters.last().is_some_and(|c| c.simple_blocks.len() == 1) {
-        clusters.pop();
+        // discard clusters added at the end for backwards-prediction
+        if cluster.timestamp * info.timestamp_scale < end_pts {
+            clusters.push(cluster);
+        }
     }
 
     Ok(Segment {