{
+ return new Promise((resolve, reject) => {
+ const targetBuffer = trackType === "video" ? this.videoSourceBuffer : this.audioSourceBuffer;
+ if (!targetBuffer) {
+ reject(new Error(`No ${trackType} SourceBuffer`));
+ return;
+ }
+
+ // Check if MediaSource is still open
+ if (!this.mediaSource || this.mediaSource.readyState !== "open") {
+ reject(new Error(`MediaSource not open (state: ${this.mediaSource?.readyState})`));
+ return;
+ }
+
+ // Check if buffer is still updating
+ if (targetBuffer.updating) {
+ reject(new Error(`${trackType} SourceBuffer still updating`));
+ return;
+ }
+
+ const isInit = this.isInitSegment(data);
+ const isMedia = this.isMediaSegment(data);
+
+ if (isInit) {
+ console.log(`[MoqMsePlayer] Appending ${trackType} INIT segment, size:`, data.byteLength);
+ } else if (isMedia) {
+ this.log(`[MoqMsePlayer] Appending ${trackType} media segment, size:`, data.byteLength);
+ } else {
+ console.warn(
+ `[MoqMsePlayer] Unknown ${trackType} segment type, first bytes:`,
+ Array.from(data.slice(0, 16))
+ .map((b) => b.toString(16).padStart(2, "0"))
+ .join(" "),
+ );
+ }
+
+ try {
+ // Cast to BufferSource to handle TypeScript lib compatibility
+ targetBuffer.appendBuffer(data as unknown as BufferSource);
+ } catch (e: unknown) {
+ const error = e as Error;
+ console.error(`[MoqMsePlayer] ${trackType} appendBuffer failed:`, error.name, error.message);
+ reject(error);
+ return;
+ }
+
+ const onUpdateEnd = () => {
+ targetBuffer.removeEventListener("updateend", onUpdateEnd);
+
+ if (targetBuffer.buffered.length > 0) {
+ const start = targetBuffer.buffered.start(0);
+ const end = targetBuffer.buffered.end(targetBuffer.buffered.length - 1);
+ // Diagnostic log - log frequently for now to debug "only 1 segment" issue
+ console.log(
+ `[MoqMsePlayer] ${trackType} UpdateEnd. Range: ${start.toFixed(3)}-${end.toFixed(3)} (Ranges: ${targetBuffer.buffered.length})`,
+ );
+ }
+ resolve();
+ };
+
+ targetBuffer.addEventListener("updateend", onUpdateEnd);
+ });
+ }
+
+ private cleanupBuffer(aggressive = false) {
+ const currentTime = this.video.currentTime;
+ const keepDuration = aggressive ? 5 : 60;
+
+ // Cleanup both buffers
+ for (const buffer of [this.videoSourceBuffer, this.audioSourceBuffer]) {
+ if (!buffer || buffer.updating) continue;
+
+ const buffered = buffer.buffered;
+ for (let i = 0; i < buffered.length; i++) {
+ const start = buffered.start(i);
+ const end = buffered.end(i);
+
+ if (end < currentTime - keepDuration) {
+ this.log(`[MoqMsePlayer] Cleaning up buffer: ${start.toFixed(2)}-${end.toFixed(2)}`);
+ buffer.remove(start, end);
+ return;
+ } else if (start < currentTime - keepDuration) {
+ this.log(
+ `[MoqMsePlayer] Cleaning up buffer: ${start.toFixed(2)}-${(currentTime - keepDuration).toFixed(2)}`,
+ );
+ buffer.remove(start, currentTime - keepDuration);
+ return;
+ }
+ }
+ }
+ }
+
+ private checkLiveEdge() {
+ if (!this.videoSourceBuffer) return;
+ try {
+ const buffered = this.videoSourceBuffer?.buffered;
+ if (!buffered || buffered.length === 0) {
+ // this.log(`[MoqMsePlayer] Buffer empty. Time: ${this.video.currentTime.toFixed(2)}`);
+ return;
+ }
+
+ // Log fragmentation if > 1 range
+ if (buffered.length > 1) {
+ const ranges = [];
+ for (let i = 0; i < buffered.length; i++)
+ ranges.push(`${buffered.start(i).toFixed(3)}-${buffered.end(i).toFixed(3)}`);
+ console.warn(`[MoqMsePlayer] Fragmented Buffer: ${ranges.join(", ")}`);
+ }
+
+ const bufferedEnd = buffered.end(buffered.length - 1);
+ const bufferedStart = buffered.start(0);
+ const currentTime = this.video.currentTime;
+ const paused = this.video.paused;
+
+ if (paused) {
+ if (this.userPaused) return;
+
+ const bufferDuration = bufferedEnd - bufferedStart;
+ this.log(
+ `[MoqMsePlayer] Paused. Buffer: ${bufferDuration.toFixed(2)}s (${bufferedStart.toFixed(2)}-${bufferedEnd.toFixed(2)})`,
+ );
+
+ // Check if we need to start playing
+ // If we are way behind the buffer start (e.g. at 0 while buffer is at 500), seek immediately
+ const isOutOfSync = currentTime < bufferedStart - 0.5;
+
+ // console.log(`[MoqMsePlayer] Autoplay Check: autoplay=${this.video.autoplay}, bufferDuration=${bufferDuration.toFixed(3)}, isOutOfSync=${isOutOfSync}, currentTime=${currentTime.toFixed(3)}, bufferedStart=${bufferedStart.toFixed(3)}`);
+
+ // Relaxed condition: If out of sync, try to recover even if buffer is tiny (it might grow)
+ if (this.video.autoplay && (bufferDuration > 0.1 || isOutOfSync)) {
+ // Seek to live edge before playing
+ if (currentTime < bufferedStart || currentTime > bufferedEnd) {
+ const targetTime = Math.max(bufferedStart, bufferedEnd - 1.0);
+ console.log(
+ `[MoqMsePlayer] Seeking to live edge: ${targetTime.toFixed(2)}s (was at ${currentTime.toFixed(2)}s) range=${bufferedStart.toFixed(2)}-${bufferedEnd.toFixed(2)}`,
+ );
+ this.video.currentTime = targetTime;
+ }
+ this.log("[MoqMsePlayer] Attempting autoplay...");
+ this.video.play().catch((e) => console.error("[MoqMsePlayer] Autoplay failed:", e));
+ }
+ return;
+ }
+
+ // HLS.js-style Live Sync
+ const targetLatency = 2.0;
+ const latency = bufferedEnd - currentTime;
+
+ // Hard Seek if too far behind
+ const isOutOfSync = currentTime < bufferedStart - 0.5;
+ if (latency > 5.0 || isOutOfSync) {
+ // Ensure we don't seek before the actual buffer start
+ const safeTarget = Math.max(bufferedStart, bufferedEnd - targetLatency);
+
+ this.log(
+ `[MoqMsePlayer] Sync adjustment: latency=${latency.toFixed(2)}s, outOfSync=${isOutOfSync}, seeking to ${safeTarget.toFixed(2)}s coverage=${bufferedStart.toFixed(2)}-${bufferedEnd.toFixed(2)}`,
+ );
+
+ if (Math.abs(currentTime - safeTarget) > 0.5) {
+ this.video.currentTime = safeTarget;
+ }
+ return;
+ }
+
+ // Catch-up via Playback Rate
+ if (latency > 3.0) {
+ if (this.video.playbackRate !== 1.1) {
+ this.log(`[MoqMsePlayer] Catching up (latency ${latency.toFixed(2)}s), rate -> 1.1x`);
+ this.video.playbackRate = 1.1;
+ }
+ } else if (latency < 2.0 && latency > -0.5) {
+ if (this.video.playbackRate !== 1.0) {
+ this.log(`[MoqMsePlayer] Latency good (${latency.toFixed(2)}s), rate -> 1.0x`);
+ this.video.playbackRate = 1.0;
+ }
+ } else if (latency <= -0.5) {
+ const targetPos = Math.max(0, bufferedEnd - 0.1);
+ this.log(
+ `[MoqMsePlayer] Ahead of buffer (${latency.toFixed(2)}s), seeking to ${targetPos.toFixed(2)}s`,
+ );
+ this.video.pause();
+ this.video.currentTime = targetPos;
+ }
+
+ // Update Debug Overlay
+ if (this.hasAttribute("debug")) {
+ this.updateDebugOverlay(latency, bufferedStart, bufferedEnd);
+ }
+
+ // Regular buffer cleanup
+ this.cleanupBuffer();
+ } catch (_e) {
+ // console.error("[MoqMsePlayer] checkLiveEdge error:", e);
+ }
+ }
+
+ private updateDebugOverlay(latency: number, bufferedStart: number, bufferedEnd: number) {
+ try {
+ let debugEl = this.shadowRoot?.querySelector(".debug-overlay") as HTMLDivElement | null;
+ if (!debugEl) {
+ debugEl = document.createElement("div");
+ debugEl.className = "debug-overlay";
+ this.shadowRoot?.appendChild(debugEl);
+ }
+
+ const quality = this.video.getVideoPlaybackQuality?.() ?? null;
+ const dropped = quality?.droppedVideoFrames ?? 0;
+ const total = quality?.totalVideoFrames ?? 0;
+ const vRanges = this.videoSourceBuffer?.buffered.length ?? 0;
+ const aRanges = this.audioSourceBuffer?.buffered.length ?? 0;
+ const vQ = this.videoQueue.length;
+ const aQ = this.audioQueue.length;
+
+ debugEl.innerHTML = `
+ Latency: ${latency.toFixed(3)}s
+ Buffer: ${bufferedStart.toFixed(2)} - ${bufferedEnd.toFixed(2)}s (${(bufferedEnd - bufferedStart).toFixed(2)}s)
+ Ranges: V=${vRanges} A=${aRanges}
+ Rate: ${this.video.playbackRate.toFixed(2)}x
+ Res: ${this.video.videoWidth}x${this.video.videoHeight}
+ Time: ${this.video.currentTime.toFixed(2)}s
+ State: ${this.connectionState}
+ Queue: V=${vQ} A=${aQ}
+ Init: V=${this.videoInitReceived ? "\u2713" : "..."} A=${this.audioInitReceived ? "\u2713" : "..."}
+ Ready: ${this.video.readyState} | Net: ${this.video.networkState}
+ Dropped: ${dropped} / ${total}
+ `;
+ } catch (e) {
+ console.error("Debug overlay error:", e);
+ }
+ }
+
+ // --- MP4 Patching for Missing Durations ---
+
+ private patchInitSegment(data: Uint8Array) {
+ try {
+ this.log(`[MP4 Patch] Scanning Init Segment (${data.byteLength} bytes)...`);
+ const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+
+ // Step 1: Map Track IDs to Types and Timescales
+ const tracks = new Map();
+
+ // Find MOOV
+ const moov = this.findBox(view, 0, "moov");
+ if (!moov) {
+ this.log("[MP4 Patch] No moov box found!");
+ return;
+ }
+
+ // Iterate MOOV children to find TRAKs
+ let offset = moov.start + 8;
+ while (offset < moov.end) {
+ const box = this.readBoxHeader(view, offset);
+ if (box.size === 0) break;
+
+ if (box.type === "trak") {
+ const info = this.parseTrak(view, box.start, box.end);
+ if (info) {
+ tracks.set(info.id, info);
+ this.log(`[MP4 Patch] Found Track ID=${info.id} Type=${info.type} Timescale=${info.timescale}`);
+ // Store timescales for sync calculation
+ if (info.type === "vide") this.videoTimescale = info.timescale;
+ if (info.type === "soun") this.audioTimescale = info.timescale;
+ }
+ }
+ offset += box.size;
+ }
+
+ // Step 2: Update TREX boxes in MVEX
+ const mvex = this.findBox(view, moov.start + 8, "mvex", moov.end);
+ if (mvex) {
+ let inner = mvex.start + 8;
+ while (inner < mvex.end) {
+ const box = this.readBoxHeader(view, inner);
+ if (box.type === "trex") {
+ this.updateTrex(view, inner, tracks);
+ }
+ inner += box.size;
+ }
+ }
+ } catch (e) {
+ console.error("[MoqMsePlayer] Error patching init segment:", e);
+ }
+ }
+
+ private findBox(
+ view: DataView,
+ start: number,
+ type: string,
+ max: number = -1,
+ ): { start: number; end: number; size: number } | null {
+ let offset = start;
+ const limit = max > 0 ? max : view.byteLength;
+ while (offset + 8 <= limit) {
+ const size = view.getUint32(offset);
+ const name = String.fromCharCode(
+ view.getUint8(offset + 4),
+ view.getUint8(offset + 5),
+ view.getUint8(offset + 6),
+ view.getUint8(offset + 7),
+ );
+ if (name === type) {
+ return { start: offset, end: offset + size, size };
+ }
+ if (size <= 0 || offset + size > limit) break; // Invalid
+
+ // Container boxes to recurse? No, simple linear scan for now, caller handles hierarchy
+ // If we receive a max, we assume we are scanning siblings
+ offset += size;
+ }
+ return null;
+ }
+
+ private readBoxHeader(view: DataView, offset: number) {
+ const size = view.getUint32(offset);
+ const type = String.fromCharCode(
+ view.getUint8(offset + 4),
+ view.getUint8(offset + 5),
+ view.getUint8(offset + 6),
+ view.getUint8(offset + 7),
+ );
+ return { size, type, start: offset, end: offset + size };
+ }
+
+ private parseTrak(
+ view: DataView,
+ start: number,
+ end: number,
+ ): { id: number; type: string; timescale: number } | null {
+ let id = 0;
+ let type = "unknown";
+ let timescale = 0;
+
+ // Scan children: tkhd, mdia
+ const offset = start + 8;
+
+ // Find TKHD
+ const tkhd = this.findBox(view, offset, "tkhd", end);
+ if (tkhd) {
+ const version = view.getUint8(tkhd.start + 8);
+ // Version(1)+Flags(3) = 4.
+ // Creation(4/8) + Mod(4/8)
+ let ptr = tkhd.start + 12;
+ if (version === 1) ptr += 16;
+ else ptr += 8;
+ id = view.getUint32(ptr);
+ }
+
+ // Find MDIA
+ const mdia = this.findBox(view, offset, "mdia", end);
+ if (mdia) {
+ // Find MDHD inside MDIA
+ const mdhd = this.findBox(view, mdia.start + 8, "mdhd", mdia.end);
+ if (mdhd) {
+ const version = view.getUint8(mdhd.start + 8);
+ let ptr = mdhd.start + 12;
+ if (version === 1) ptr += 16;
+ else ptr += 8; // Skip stamps
+ timescale = view.getUint32(ptr);
+ }
+ // Find HDLR inside MDIA
+ const hdlr = this.findBox(view, mdia.start + 8, "hdlr", mdia.end);
+ if (hdlr) {
+ // Ver(4), Pre(4), Type(4)
+ const typeOffset = hdlr.start + 16;
+ type = String.fromCharCode(
+ view.getUint8(typeOffset),
+ view.getUint8(typeOffset + 1),
+ view.getUint8(typeOffset + 2),
+ view.getUint8(typeOffset + 3),
+ );
+ }
+ }
+
+ if (id && timescale) return { id, type, timescale };
+ return null;
+ }
+
+ private updateTrex(view: DataView, offset: number, tracks: Map) {
+ // trek: Size(4), Type(4), VerFlags(4), TrackID(4), DefDescIdx(4), DefDur(4)...
+ const trackId = view.getUint32(offset + 12);
+ const info = tracks.get(trackId);
+
+ const currentDuration = view.getUint32(offset + 20);
+
+ if (info && currentDuration === 0) {
+ let newDuration = 0;
+ if (info.type === "vide") {
+ // Assume 30fps if unknown
+ newDuration = Math.floor(info.timescale / 30);
+ } else if (info.type === "soun") {
+ // AAC default is 1024 samples
+ newDuration = 1024;
+ }
+
+ if (newDuration > 0) {
+ this.log(
+ `[MP4 Patch] Overwriting TREX duration for Track ${trackId} (${info.type}). Old=${currentDuration}, New=${newDuration}`,
+ );
+ view.setUint32(offset + 20, newDuration); // Big Endian default
+ }
+ } else {
+ // this.log(`[MP4 Patch] TREX Track ${trackId} has duration ${currentDuration} (Type: ${info?.type})`);
+ }
+ }
+
+ // Debug: Inspect MP4 atoms to find timescale/duration issues
+ private inspectLogCount = 0;
+
+ private inspectMP4(data: Uint8Array, label: string): number | null {
+ // Rate limit logging, but ALWAYS parse audio if we need its first timestamp for sync
+ const isAudio = label.includes("audio");
+ const needAudioTimestamp = isAudio && this.firstAudioTimestamp === null;
+
+ if (this.inspectLogCount > 10 && label.includes("Media") && !label.includes("video") && !needAudioTimestamp) {
+ return null; // Limit spam, but allow video and first audio timestamp capture
+ }
+ if (label.includes("Media")) this.inspectLogCount++;
+
+ let foundTimestamp: number | null = null;
+
+ try {
+ let offset = 0;
+ const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+
+ this.log(`[MP4 Debug] Inspecting ${label} (${data.byteLength} bytes)`);
+
+ let iter = 0;
+ while (offset < data.byteLength && iter < 50) {
+ iter++;
+ if (offset + 8 > data.byteLength) break;
+ const size = view.getUint32(offset);
+ const type = String.fromCharCode(
+ view.getUint8(offset + 4),
+ view.getUint8(offset + 5),
+ view.getUint8(offset + 6),
+ view.getUint8(offset + 7),
+ );
+
+ const boxSize = size === 0 ? data.byteLength - offset : size;
+ this.log(` Box: ${type}, Size: ${boxSize} (Offset: ${offset})`);
+
+ if (type === "mdhd") {
+ this.parseMdhd(view, offset + 8);
+ }
+ if (type === "trun") {
+ this.parseTrun(view, offset + 8);
+ }
+ if (type === "tfdt") {
+ foundTimestamp = this.parseTfdt(view, offset + 8);
+ }
+
+ if (["moov", "trak", "mdia", "minf", "stbl", "mvex", "moof", "traf"].includes(type)) {
+ offset += 8; // Enter container
+ } else {
+ offset += boxSize; // Skip leaf
+ }
+ }
+ } catch (e) {
+ this.log(`[MP4 Debug] Error inspecting: ${e}`);
+ }
+
+ return foundTimestamp;
+ }
+
+ private parseTfdt(view: DataView, offset: number): number {
+ // Version(1), Flags(3), BaseMediaDecodeTime(4 or 8)
+ const version = view.getUint8(offset);
+ let baseMediaDecodeTime = 0;
+ if (version === 1) {
+ // 64-bit: high 32, low 32. JS only supports reading 32 safely or BigInt.
+ // Let's assume high 32 is 0 or use BigInt if possible, but logging simple number
+ const high = view.getUint32(offset + 4);
+ const low = view.getUint32(offset + 8);
+ // If high is > 0 this might be inaccurate as number, but fine for debug logs usually
+ baseMediaDecodeTime = high * 4294967296 + low;
+ this.log(` [tfdt] BaseMediaDecodeTime (64-bit): ${baseMediaDecodeTime}`);
+ } else {
+ baseMediaDecodeTime = view.getUint32(offset + 4);
+ this.log(` [tfdt] BaseMediaDecodeTime (32-bit): ${baseMediaDecodeTime}`);
+ }
+ return baseMediaDecodeTime;
+ }
+
+ private parseMdhd(view: DataView, offset: number) {
+ if (offset + 24 > view.byteLength) return;
+ const version = view.getUint8(offset);
+ let ptr = offset + 4;
+ if (version === 1) {
+ ptr += 16;
+ } else {
+ ptr += 8;
+ }
+ if (ptr + 4 <= view.byteLength) {
+ const timescale = view.getUint32(ptr);
+ this.log(` [mdhd] Version: ${version}, Timescale: ${timescale}`);
+ }
+ }
+
+ private parseTrun(view: DataView, offset: number) {
+ if (offset + 12 > view.byteLength) return;
+ const fullFlags = view.getUint32(offset);
+ const flags = fullFlags & 0xffffff;
+ const sampleCount = view.getUint32(offset + 4);
+
+ const durationPresent = (flags & 0x100) !== 0;
+
+ this.log(` [trun] SampleCount: ${sampleCount}, DurationPresent: ${durationPresent}`);
+
+ if (durationPresent && sampleCount > 0) {
+ let ptr = offset + 8;
+ if (flags & 0x01) ptr += 4;
+ if (flags & 0x04) ptr += 4;
+
+ if (ptr + 4 <= view.byteLength) {
+ const firstDuration = view.getUint32(ptr);
+ this.log(` [trun] First Sample Duration: ${firstDuration}`);
+ }
+ } else {
+ this.log(` [trun] No duration present in samples.`);
+ }
+ }
+}
+
+// Register the custom element
+customElements.define("moq-mse-player", MoqMsePlayer);
+
+declare global {
+ interface HTMLElementTagNameMap {
+ "moq-mse-player": MoqMsePlayer;
+ }
+}
diff --git a/js/hang-demo/src/watch-mse.html b/js/hang-demo/src/watch-mse.html
new file mode 100644
index 000000000..d18b983da
--- /dev/null
+++ b/js/hang-demo/src/watch-mse.html
@@ -0,0 +1,105 @@
+
+
+
+
+
+
+ MoQ MSE Player Demo
+
+
+
+
+
+
+ MSE Player Demo
+
+
+ This demo uses MediaSource Extensions for native <video> playback.
+ It requires publishing with fmp4-mse mode (complete fMP4 segments).
+
+
+
+
+
+
+ How to Use
+
+ You must publish using the MSE-compatible segment mode:
+
+ # Publish with MSE mode (fMP4 segments)
+just pub-mse bbb
+
+# Or manually:
+ffmpeg -i input.mp4 -c copy -f mp4 \
+ -movflags cmaf+separate_moof+delay_moov+skip_trailer+frag_every_frame \
+ - | cargo run --bin hang -- publish --url "http://localhost:4443/anon" --name "bbb" fmp4-mse
+
+ Live Sync Strategies
+
+ This player implements HLS.js-style live sync:
+
+
+ - Target latency: ~2 seconds behind live edge
+ - Catch-up: Speeds up to 1.1x when latency > 3s
+ - Hard seek: Jumps to live edge when latency > 5s
+ - Buffer cleanup: Removes old data after 60s (5s if quota exceeded)
+
+
+ WebCodecs vs MSE
+
+
+
+ | Feature |
+ WebCodecs (<hang-watch>) |
+ MSE (<moq-mse-player>) |
+
+
+
+
+ | Render Target |
+ <canvas> |
+ <video> |
+
+
+ | Native Controls |
+ ❌ Custom |
+ ✅ Built-in |
+
+
+ | Latency |
+ ⚡ Ultra-low |
+ 📊 ~2s target |
+
+
+ | Browser Support |
+ Chrome, Edge |
+ All modern |
+
+
+ | Publish Mode |
+ just pub bbb |
+ just pub-mse bbb |
+
+
+
+
+
+ ← Back to WebCodecs demo
+
+
+
+
+
+
diff --git a/js/hang-demo/src/watch-mse.ts b/js/hang-demo/src/watch-mse.ts
new file mode 100644
index 000000000..40f89f884
--- /dev/null
+++ b/js/hang-demo/src/watch-mse.ts
@@ -0,0 +1,12 @@
+import "./highlight";
+import "./mse/moq-mse-player";
+
+// Allow overriding broadcast path via query parameter
+const player = document.querySelector("moq-mse-player");
+if (player) {
+ const urlParams = new URLSearchParams(window.location.search);
+ const path = urlParams.get("path");
+ if (path) {
+ player.setAttribute("path", path);
+ }
+}
diff --git a/js/hang-demo/vite.config.ts b/js/hang-demo/vite.config.ts
index a64e72788..ed276e9b4 100644
--- a/js/hang-demo/vite.config.ts
+++ b/js/hang-demo/vite.config.ts
@@ -11,6 +11,7 @@ export default defineConfig({
rollupOptions: {
input: {
watch: "index.html",
+ "watch-mse": "watch-mse.html",
publish: "publish.html",
support: "support.html",
meet: "meet.html",
diff --git a/justfile b/justfile
index 6bce2cb33..a99c2be00 100644
--- a/justfile
+++ b/justfile
@@ -146,6 +146,23 @@ pub name url="http://localhost:4443/anon" *args:
-f mp4 -movflags cmaf+separate_moof+delay_moov+skip_trailer+frag_every_frame \
- | cargo run --bin hang -- publish --url "{{url}}" --name "{{name}}" fmp4 {{args}}
+# Publish a video using MSE-compatible fMP4 segments (for browser MSE playback)
+# This sends complete moof+mdat segments instead of individual frames.
+pub-mse name url="http://localhost:4443/anon" *args:
+ # Download the sample media.
+ just download "{{name}}"
+
+ # Pre-build the binary so we don't queue media while compiling.
+ cargo build --bin hang
+
+ # Run ffmpeg and pipe the output to hang with MSE segment mode
+ ffmpeg -hide_banner -v quiet \
+ -stream_loop -1 -re \
+ -i "dev/{{name}}.fmp4" \
+ -c copy \
+ -f mp4 -movflags cmaf+separate_moof+delay_moov+skip_trailer+frag_every_frame \
+ - | cargo run --bin hang -- publish --url "{{url}}" --name "{{name}}" fmp4-mse {{args}}
+
# Generate and ingest an HLS stream from a video file.
pub-hls name relay="http://localhost:4443/anon":
#!/usr/bin/env bash
diff --git a/rs/hang-cli/src/publish.rs b/rs/hang-cli/src/publish.rs
index eb12d8771..536e0b63f 100644
--- a/rs/hang-cli/src/publish.rs
+++ b/rs/hang-cli/src/publish.rs
@@ -1,7 +1,7 @@
use bytes::BytesMut;
use clap::Subcommand;
use hang::{
- import::{Decoder, DecoderFormat},
+ import::{Decoder, DecoderFormat, Fmp4, ImportMode},
moq_lite::BroadcastConsumer,
BroadcastProducer,
};
@@ -10,7 +10,10 @@ use tokio::io::AsyncReadExt;
#[derive(Subcommand, Clone)]
pub enum PublishFormat {
Avc3,
+ /// fMP4 format for WebCodecs (frame-by-frame)
Fmp4,
+ /// fMP4 format for MSE (complete segments)
+ Fmp4Mse,
// NOTE: No aac support because it needs framing.
Hls {
/// URL or file path of an HLS playlist to ingest.
@@ -21,6 +24,7 @@ pub enum PublishFormat {
enum PublishDecoder {
Decoder(Box),
+ Fmp4(Box),
Hls(Box),
}
@@ -45,6 +49,11 @@ impl Publish {
let stream = Decoder::new(broadcast.clone(), format);
PublishDecoder::Decoder(Box::new(stream))
}
+ PublishFormat::Fmp4Mse => {
+ // Use Fmp4 directly with Segments mode for MSE
+ let fmp4 = Fmp4::with_mode(broadcast.clone(), ImportMode::Segments);
+ PublishDecoder::Fmp4(Box::new(fmp4))
+ }
PublishFormat::Hls { playlist } => {
let hls = hang::import::Hls::new(
broadcast.clone(),
@@ -79,6 +88,13 @@ impl Publish {
decoder.decode_stream(&mut self.buffer)?;
}
}
+ PublishDecoder::Fmp4(decoder) => {
+ let mut input = tokio::io::stdin();
+
+ while !decoder.is_initialized() && input.read_buf(&mut self.buffer).await? > 0 {
+ decoder.decode(&mut self.buffer)?;
+ }
+ }
PublishDecoder::Hls(decoder) => decoder.init().await?,
}
@@ -94,6 +110,13 @@ impl Publish {
decoder.decode_stream(&mut self.buffer)?;
}
}
+ PublishDecoder::Fmp4(decoder) => {
+ let mut input = tokio::io::stdin();
+
+ while input.read_buf(&mut self.buffer).await? > 0 {
+ decoder.decode(&mut self.buffer)?;
+ }
+ }
PublishDecoder::Hls(decoder) => decoder.run().await?,
}
diff --git a/rs/hang/src/import/fmp4.rs b/rs/hang/src/import/fmp4.rs
index 96d5f9432..87e23aaf8 100644
--- a/rs/hang/src/import/fmp4.rs
+++ b/rs/hang/src/import/fmp4.rs
@@ -6,6 +6,27 @@ use moq_lite as moq;
use mp4_atom::{Any, Atom, DecodeMaybe, Mdat, Moof, Moov, Trak};
use std::collections::HashMap;
+/// Mode for importing fMP4 content.
+///
+/// This determines how frames are transmitted over MOQ:
+/// - `Frames`: Individual frames for WebCodecs (lower latency)
+/// - `Segments`: Complete fMP4 segments for MSE (broader compatibility)
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub enum ImportMode {
+ /// Extract individual frames from segments (default, for WebCodecs).
+ ///
+ /// Each frame is sent separately with a timestamp header.
+ /// This provides the lowest latency but requires WebCodecs on the client.
+ #[default]
+ Frames,
+
+ /// Send complete fMP4 segments (moof+mdat) for MSE.
+ ///
+ /// Init segment (ftyp+moov) is sent at each keyframe.
+ /// This is compatible with MSE-based players but has slightly higher latency.
+ Segments,
+}
+
/// Converts fMP4/CMAF files into hang broadcast streams.
///
/// This struct processes fragmented MP4 (fMP4) files and converts them into hang broadcasts.
@@ -23,6 +44,11 @@ use std::collections::HashMap;
/// **Audio:**
/// - AAC (MP4A)
/// - Opus
+///
+/// ## Import Modes
+///
+/// - [`ImportMode::Frames`]: Extract individual frames (for WebCodecs)
+/// - [`ImportMode::Segments`]: Send complete fMP4 segments (for MSE)
pub struct Fmp4 {
// The broadcast being produced
// This `hang` variant includes a catalog.
@@ -44,6 +70,20 @@ pub struct Fmp4 {
// The latest moof header
moof: Option,
moof_size: usize,
+
+ // --- MSE Segment Mode fields ---
+ // Import mode (frames vs segments)
+ mode: ImportMode,
+
+ // Buffer to accumulate raw moof bytes (for Segments mode)
+ moof_buffer: BytesMut,
+
+ // Buffer to store ftyp box for init segment
+ ftyp_buffer: BytesMut,
+
+ // Per-track init segments (ftyp + moov with single track) for MSE mode
+ // Key is track_id, value is complete init segment bytes
+ track_init_segments: HashMap,
}
impl Fmp4 {
@@ -51,7 +91,22 @@ impl Fmp4 {
///
/// The broadcast will be populated with tracks as they're discovered in the
/// fMP4 file. The catalog from the `hang::BroadcastProducer` is used automatically.
+ ///
+ /// Uses [`ImportMode::Frames`] by default (for WebCodecs).
+ /// Use [`Self::with_mode`] to specify a different mode.
pub fn new(broadcast: hang::BroadcastProducer) -> Self {
+ Self::with_mode(broadcast, ImportMode::default())
+ }
+
+ /// Create a new CMAF importer with a specific import mode.
+ ///
+ /// # Arguments
+ ///
+ /// * `broadcast` - The broadcast to write tracks to
+ /// * `mode` - The import mode:
+ /// - [`ImportMode::Frames`]: Extract individual frames (for WebCodecs)
+ /// - [`ImportMode::Segments`]: Send complete fMP4 segments (for MSE)
+ pub fn with_mode(broadcast: hang::BroadcastProducer, mode: ImportMode) -> Self {
let catalog = broadcast.catalog.clone();
Self {
broadcast,
@@ -61,6 +116,10 @@ impl Fmp4 {
moov: None,
moof: None,
moof_size: 0,
+ mode,
+ moof_buffer: BytesMut::new(),
+ ftyp_buffer: BytesMut::new(),
+ track_init_segments: HashMap::default(),
}
}
@@ -71,15 +130,26 @@ impl Fmp4 {
while let Some(atom) = mp4_atom::Any::decode_maybe(&mut cursor)? {
// Process the parsed atom.
let size = cursor.position() as usize - position;
+ let atom_start = position;
position = cursor.position() as usize;
match atom {
Any::Ftyp(_) | Any::Styp(_) => {
- // Skip
+ // In Segments mode, capture ftyp bytes for init segment
+ if self.mode == ImportMode::Segments && self.ftyp_buffer.is_empty() {
+ let data = cursor.get_ref().as_ref();
+ self.ftyp_buffer.extend_from_slice(&data[atom_start..position]);
+ tracing::debug!("Captured ftyp/styp box: {} bytes", size);
+ }
}
Any::Moov(moov) => {
- // Create the broadcast.
- self.init(moov)?;
+ // Create the broadcast first
+ self.init(moov.clone())?;
+
+ // In Segments mode, create per-track init segments
+ if self.mode == ImportMode::Segments && self.track_init_segments.is_empty() {
+ self.create_per_track_init_segments(&moov)?;
+ }
}
Any::Moof(moof) => {
if self.moof.is_some() {
@@ -87,13 +157,23 @@ impl Fmp4 {
anyhow::bail!("duplicate moof box");
}
+ // In Segments mode, capture moof bytes
+ if self.mode == ImportMode::Segments {
+ self.moof_buffer.clear();
+ let data = cursor.get_ref().as_ref();
+ self.moof_buffer.extend_from_slice(&data[atom_start..position]);
+ }
+
self.moof = Some(moof);
self.moof_size = size;
}
Any::Mdat(mdat) => {
// Extract the samples from the mdat atom.
let header_size = size - mdat.data.len();
- self.extract(mdat, header_size)?;
+ match self.mode {
+ ImportMode::Frames => self.extract(mdat, header_size)?,
+ ImportMode::Segments => self.extract_segment(mdat, header_size)?,
+ }
}
_ => {
// Skip unknown atoms
@@ -142,13 +222,13 @@ impl Fmp4 {
let track = moq::Track {
name: self.broadcast.track_name("audio"),
- priority: 2,
+ priority: 1,
};
tracing::debug!(name = ?track.name, ?config, "starting track");
let audio = catalog.insert_audio(track.name.clone(), config);
- audio.priority = 2;
+ audio.priority = 1;
let track = track.produce();
self.broadcast.insert_track(track.consumer);
@@ -166,6 +246,46 @@ impl Fmp4 {
Ok(())
}
+ /// Create per-track init segments for MSE mode.
+ /// Each track needs its own ftyp + moov with only that track's info.
+ fn create_per_track_init_segments(&mut self, moov: &Moov) -> anyhow::Result<()> {
+ use mp4_atom::Encode;
+
+ for trak in &moov.trak {
+ let track_id = trak.tkhd.track_id;
+
+ // Create a new moov with only this track
+ let single_track_moov = Moov {
+ mvhd: moov.mvhd.clone(),
+ mvex: moov.mvex.clone(),
+ trak: vec![trak.clone()],
+ udta: moov.udta.clone(),
+ meta: moov.meta.clone(),
+ };
+
+ // Encode the single-track moov to bytes
+ let mut moov_bytes = BytesMut::new();
+ single_track_moov.encode(&mut moov_bytes)?;
+
+ // Create the complete init segment: ftyp + moov
+ let mut init_segment = BytesMut::new();
+ init_segment.extend_from_slice(&self.ftyp_buffer);
+ init_segment.extend_from_slice(&moov_bytes);
+
+ tracing::debug!(
+ "Created init segment for track {}: {} bytes (ftyp: {}, moov: {})",
+ track_id,
+ init_segment.len(),
+ self.ftyp_buffer.len(),
+ moov_bytes.len()
+ );
+
+ self.track_init_segments.insert(track_id, init_segment.freeze());
+ }
+
+ Ok(())
+ }
+
fn init_video(trak: &Trak) -> anyhow::Result {
let stsd = &trak.mdia.minf.stbl.stsd;
@@ -491,6 +611,236 @@ impl Fmp4 {
Ok(())
}
+
+ /// Extract complete fMP4 segment (moof + mdat) as a single frame.
+ ///
+ /// Used when [`ImportMode::Segments`] is selected for MSE compatibility.
+ fn extract_segment(&mut self, mdat: Mdat, _header_size: usize) -> anyhow::Result<()> {
+ let mdat_data = Bytes::from(mdat.data);
+ let moov = self.moov.as_ref().context("missing moov box")?;
+ let moof = self.moof.take().context("missing moof box")?;
+
+ // Loop over ALL tracks in moof
+ for traf in &moof.traf {
+ let track_id = traf.tfhd.track_id;
+
+ // Check if the track exists (immutable borrow)
+ if !self.tracks.contains_key(&track_id) {
+ tracing::warn!("Unknown track_id: {}, skipping", track_id);
+ continue;
+ }
+
+ // Find the track information in the moov
+ let trak = moov
+ .trak
+ .iter()
+ .find(|trak| trak.tkhd.track_id == track_id)
+ .context("unknown track")?;
+
+ let tfdt = traf.tfdt.as_ref().context("missing tfdt box")?;
+ let dts = tfdt.base_media_decode_time;
+ let timescale = trak.mdia.mdhd.timescale as u64;
+
+ // Calculate timestamp from DTS
+ let micros = (dts as u128 * 1_000_000 / timescale as u128) as u64;
+ let timestamp = hang::Timestamp::from_micros(micros)?;
+
+ // Check if this is a keyframe segment by looking at first sample flags
+ let keyframe = if let Some(trun) = traf.trun.first() {
+ if let Some(entry) = trun.entries.first() {
+ let trex = moov
+ .mvex
+ .as_ref()
+ .and_then(|mvex| mvex.trex.iter().find(|trex| trex.track_id == track_id));
+ let default_sample_flags = trex.map(|trex| trex.default_sample_flags).unwrap_or_default();
+
+ let flags = entry
+ .flags
+ .unwrap_or(traf.tfhd.default_sample_flags.unwrap_or(default_sample_flags));
+
+ if trak.mdia.hdlr.handler == b"vide".into() {
+ let is_keyframe = (flags >> 24) & 0x3 == 0x2; // kSampleDependsOnNoOther
+ let non_sync = (flags >> 16) & 0x1 == 0x1; // kSampleIsNonSyncSample
+
+ if is_keyframe && !non_sync {
+ // Force audio keyframe when video has a keyframe (for sync)
+ for audio in moov.trak.iter().filter(|t| t.mdia.hdlr.handler == b"soun".into()) {
+ self.last_keyframe.remove(&audio.tkhd.track_id);
+ }
+ true
+ } else {
+ false
+ }
+ } else {
+ // Audio - check if it's been 10 seconds since last keyframe
+ // OR if video just had a keyframe (last_keyframe was cleared)
+ match self.last_keyframe.get(&track_id) {
+ Some(prev) => timestamp - *prev > Timestamp::from_secs(10).unwrap(),
+ None => true, // No previous keyframe = force one now
+ }
+ }
+ } else {
+ false
+ }
+ } else {
+ false
+ };
+
+ if keyframe {
+ self.last_keyframe.insert(track_id, timestamp);
+ }
+
+ // Create complete fMP4 segment
+ let mut segment_data = BytesMut::new();
+
+ // For keyframes, prepend the per-track init segment to make each
+ // keyframe self-contained. Each track has its own init segment with
+ // only that track's moov info - this is required for MSE with separate
+ // SourceBuffers.
+ if keyframe {
+ if let Some(init_segment) = self.track_init_segments.get(&track_id) {
+ segment_data.extend_from_slice(init_segment);
+ tracing::debug!(
+ "Prepending per-track init segment to keyframe for track {}: {} bytes",
+ track_id,
+ init_segment.len()
+ );
+ }
+ }
+
+ // Build per-track moof and mdat containing only this track's data.
+ // This is required for MSE with demuxed SourceBuffers.
+ let (per_track_moof_bytes, per_track_mdat_bytes) =
+ self.build_per_track_segment(&moof.mfhd, traf, &mdat_data)?;
+
+ segment_data.extend_from_slice(&per_track_moof_bytes);
+ segment_data.extend_from_slice(&per_track_mdat_bytes);
+
+ tracing::debug!(
+ "Sending fMP4 segment: {} bytes (moof: {}, mdat: {}), keyframe: {}, timestamp: {:?}",
+ segment_data.len(),
+ per_track_moof_bytes.len(),
+ per_track_mdat_bytes.len(),
+ keyframe,
+ timestamp
+ );
+
+ let frame = hang::Frame {
+ timestamp,
+ keyframe,
+ payload: segment_data.freeze().into(),
+ };
+
+ // Now get mutable reference to write the frame
+ let track = self.tracks.get_mut(&track_id).context("track disappeared")?;
+ track.write(frame)?;
+ }
+
+ Ok(())
+ }
+
+ /// Build a per-track moof and mdat pair containing only the specified track's data.
+ ///
+ /// This is required for MSE with demuxed SourceBuffers, where each buffer
+ /// expects to receive data for only its track.
+ fn build_per_track_segment(
+ &self,
+ mfhd: &mp4_atom::Mfhd,
+ traf: &mp4_atom::Traf,
+ global_mdat: &Bytes,
+ ) -> anyhow::Result<(Bytes, Bytes)> {
+ use mp4_atom::Encode;
+
+ let moov = self.moov.as_ref().context("missing moov box")?;
+ let track_id = traf.tfhd.track_id;
+ let trex = moov
+ .mvex
+ .as_ref()
+ .and_then(|mvex| mvex.trex.iter().find(|trex| trex.track_id == track_id));
+ let default_sample_size = trex.map(|trex| trex.default_sample_size).unwrap_or_default();
+
+ // First, extract all sample data for this track from the global mdat
+ let mut track_mdat_data = BytesMut::new();
+ let mut offset = traf.tfhd.base_data_offset.unwrap_or_default() as usize;
+
+ for trun in &traf.trun {
+ if let Some(data_offset) = trun.data_offset {
+ let base_offset = traf.tfhd.base_data_offset.unwrap_or_default() as usize;
+ // data_offset is relative to the start of the moof
+ let data_offset_usize: usize = data_offset.try_into().context("invalid data offset")?;
+ if data_offset_usize < self.moof_size {
+ anyhow::bail!(
+ "invalid data offset: {} < moof_size {}",
+ data_offset_usize,
+ self.moof_size
+ );
+ }
+ // Calculate offset into mdat (moof_size is subtracted, and we also need to
+ // account for the 8-byte mdat header that was stripped when parsing)
+ offset = base_offset + data_offset_usize - self.moof_size - 8;
+ }
+
+ for entry in &trun.entries {
+ let size = entry
+ .size
+ .unwrap_or(traf.tfhd.default_sample_size.unwrap_or(default_sample_size)) as usize;
+
+ if offset + size > global_mdat.len() {
+ anyhow::bail!("invalid sample offset: {} + {} > {}", offset, size, global_mdat.len());
+ }
+
+ track_mdat_data.extend_from_slice(&global_mdat[offset..offset + size]);
+ offset += size;
+ }
+ }
+
+ // Now build the per-track moof with updated trun data_offsets
+ // Clone traf and update trun data_offsets
+ let mut new_traf = traf.clone();
+
+ // Create a temporary moof to calculate its size
+ let temp_moof = Moof {
+ mfhd: mfhd.clone(),
+ traf: vec![new_traf.clone()],
+ };
+ let mut temp_moof_bytes = BytesMut::new();
+ temp_moof.encode(&mut temp_moof_bytes)?;
+ let new_moof_size = temp_moof_bytes.len();
+
+ // Now update the trun data_offsets to point into the new per-track mdat
+ // data_offset should be: new_moof_size + 8 (mdat header) + offset_within_track_mdat
+ let mut current_offset_in_track_mdat: i32 = 0;
+ for trun in &mut new_traf.trun {
+ // Set data_offset to point to the start of this trun's samples in the per-track mdat
+ // The offset is relative to the start of the moof
+ trun.data_offset = Some((new_moof_size as i32) + 8 + current_offset_in_track_mdat);
+
+ // Calculate how many bytes this trun consumes
+ for entry in &trun.entries {
+ let size = entry
+ .size
+ .unwrap_or(traf.tfhd.default_sample_size.unwrap_or(default_sample_size));
+ current_offset_in_track_mdat += size as i32;
+ }
+ }
+
+ // Build the final per-track moof
+ let per_track_moof = Moof {
+ mfhd: mfhd.clone(),
+ traf: vec![new_traf],
+ };
+ let mut moof_bytes = BytesMut::new();
+ per_track_moof.encode(&mut moof_bytes)?;
+
+ // Build the per-track mdat: 4 bytes size + 4 bytes 'mdat' + data
+ let mdat_size = (8 + track_mdat_data.len()) as u32;
+ let mut mdat_bytes = BytesMut::new();
+ mdat_bytes.extend_from_slice(&mdat_size.to_be_bytes());
+ mdat_bytes.extend_from_slice(b"mdat");
+ mdat_bytes.extend_from_slice(&track_mdat_data);
+
+ Ok((moof_bytes.freeze(), mdat_bytes.freeze()))
+ }
}
impl Drop for Fmp4 {
@@ -506,3 +856,276 @@ impl Drop for Fmp4 {
}
}
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use mp4_atom::{Mfhd, Tfdt, Tfhd, Traf, Trun, TrunEntry};
+
+ /// Test that build_per_track_segment creates a moof with only one traf
+ /// and an mdat containing only that track's samples.
+ #[test]
+ fn test_per_track_moof_mdat_extraction() {
+ // Create a mock mfhd (movie fragment header)
+ let mfhd = Mfhd { sequence_number: 1 };
+
+ // Create sample data that would be in the global mdat
+ // Track 1 samples: [0x11, 0x12, 0x13] (3 bytes) + [0x14, 0x15] (2 bytes) = 5 bytes
+ // Track 2 samples: [0x21, 0x22, 0x23, 0x24] (4 bytes) = 4 bytes
+ let track1_sample1 = vec![0x11, 0x12, 0x13];
+ let track1_sample2 = vec![0x14, 0x15];
+ let track2_sample1 = vec![0x21, 0x22, 0x23, 0x24];
+
+ // Simulate mdat containing both tracks' data
+ let mut global_mdat_data = BytesMut::new();
+ global_mdat_data.extend_from_slice(&track1_sample1);
+ global_mdat_data.extend_from_slice(&track1_sample2);
+ global_mdat_data.extend_from_slice(&track2_sample1);
+ let global_mdat = global_mdat_data.freeze();
+
+ // Create traf for track 1
+ // The data_offset points to after the moof (we'll use a mock moof_size)
+ let mock_moof_size = 100; // Assume moof is 100 bytes
+ let mdat_header_size = 8; // mdat box header
+
+ let traf1 = Traf {
+ tfhd: Tfhd {
+ track_id: 1,
+ base_data_offset: None,
+ sample_description_index: Some(1),
+ default_sample_duration: Some(1024),
+ default_sample_size: None,
+ default_sample_flags: None,
+ },
+ tfdt: Some(Tfdt {
+ base_media_decode_time: 0,
+ }),
+ trun: vec![Trun {
+ // data_offset is relative to moof start, points to mdat data
+ data_offset: Some((mock_moof_size + mdat_header_size) as i32),
+ entries: vec![
+ TrunEntry {
+ duration: Some(1024),
+ size: Some(3), // 3 bytes
+ flags: Some(0x02000000), // keyframe
+ cts: Some(0),
+ },
+ TrunEntry {
+ duration: Some(1024),
+ size: Some(2), // 2 bytes
+ flags: Some(0x01010000), // non-keyframe
+ cts: Some(0),
+ },
+ ],
+ }],
+ ..Default::default()
+ };
+
+ // Create traf for track 2
+ let traf2 = Traf {
+ tfhd: Tfhd {
+ track_id: 2,
+ base_data_offset: None,
+ sample_description_index: Some(1),
+ default_sample_duration: Some(1024),
+ default_sample_size: None,
+ default_sample_flags: None,
+ },
+ tfdt: Some(Tfdt {
+ base_media_decode_time: 0,
+ }),
+ trun: vec![Trun {
+ // Track 2 data starts at offset 5 (after track 1's 5 bytes)
+ data_offset: Some((mock_moof_size + mdat_header_size + 5) as i32),
+ entries: vec![TrunEntry {
+ duration: Some(1024),
+ size: Some(4), // 4 bytes
+ flags: Some(0x02000000), // keyframe
+ cts: Some(0),
+ }],
+ }],
+ ..Default::default()
+ };
+
+ // Test extracting track 1
+ let (moof_bytes, mdat_bytes) = build_per_track_segment_standalone(&mfhd, &traf1, &global_mdat, mock_moof_size);
+
+ // Verify mdat contains only track 1 samples (5 bytes + 8 byte header)
+ assert_eq!(
+ mdat_bytes.len(),
+ 8 + 5,
+ "Track 1 mdat should be 13 bytes (8 header + 5 data)"
+ );
+
+ // Verify mdat header
+ let mdat_size = u32::from_be_bytes([mdat_bytes[0], mdat_bytes[1], mdat_bytes[2], mdat_bytes[3]]);
+ assert_eq!(mdat_size, 13, "Track 1 mdat size field should be 13");
+ assert_eq!(&mdat_bytes[4..8], b"mdat", "mdat fourcc should be 'mdat'");
+
+ // Verify mdat data content
+ assert_eq!(&mdat_bytes[8..11], &[0x11, 0x12, 0x13], "Track 1 sample 1 data");
+ assert_eq!(&mdat_bytes[11..13], &[0x14, 0x15], "Track 1 sample 2 data");
+
+ // Verify moof contains only one traf
+ let decoded_moof = decode_moof(&moof_bytes);
+ assert_eq!(decoded_moof.traf.len(), 1, "Per-track moof should have exactly 1 traf");
+ assert_eq!(decoded_moof.traf[0].tfhd.track_id, 1, "Traf should be for track 1");
+
+ // Test extracting track 2
+ let (moof_bytes2, mdat_bytes2) =
+ build_per_track_segment_standalone(&mfhd, &traf2, &global_mdat, mock_moof_size);
+
+ // Verify mdat contains only track 2 samples (4 bytes + 8 byte header)
+ assert_eq!(
+ mdat_bytes2.len(),
+ 8 + 4,
+ "Track 2 mdat should be 12 bytes (8 header + 4 data)"
+ );
+
+ // Verify mdat data content
+ assert_eq!(&mdat_bytes2[8..12], &[0x21, 0x22, 0x23, 0x24], "Track 2 sample data");
+
+ // Verify moof contains only one traf for track 2
+ let decoded_moof2 = decode_moof(&moof_bytes2);
+ assert_eq!(decoded_moof2.traf.len(), 1, "Per-track moof should have exactly 1 traf");
+ assert_eq!(decoded_moof2.traf[0].tfhd.track_id, 2, "Traf should be for track 2");
+ }
+
+ /// Test that data_offset in the per-track moof points correctly into the per-track mdat
+ #[test]
+ fn test_per_track_data_offset() {
+ let mfhd = Mfhd { sequence_number: 1 };
+
+ // Single sample of 10 bytes
+ let sample_data = vec![0xAA; 10];
+ let global_mdat = Bytes::from(sample_data.clone());
+
+ let mock_moof_size = 80;
+ let mdat_header_size = 8;
+
+ let traf = Traf {
+ tfhd: Tfhd {
+ track_id: 1,
+ base_data_offset: None,
+ sample_description_index: Some(1),
+ default_sample_duration: Some(1024),
+ default_sample_size: None,
+ default_sample_flags: None,
+ },
+ tfdt: Some(Tfdt {
+ base_media_decode_time: 0,
+ }),
+ trun: vec![Trun {
+ data_offset: Some((mock_moof_size + mdat_header_size) as i32),
+ entries: vec![TrunEntry {
+ duration: Some(1024),
+ size: Some(10),
+ flags: Some(0x02000000),
+ cts: Some(0),
+ }],
+ }],
+ ..Default::default()
+ };
+
+ let (moof_bytes, mdat_bytes) = build_per_track_segment_standalone(&mfhd, &traf, &global_mdat, mock_moof_size);
+
+ // Decode the moof to check the data_offset
+ let decoded_moof = decode_moof(&moof_bytes);
+ let new_moof_size = moof_bytes.len();
+
+ // The data_offset should point to right after the moof + mdat header
+ let expected_data_offset = (new_moof_size + 8) as i32;
+ assert_eq!(
+ decoded_moof.traf[0].trun[0].data_offset,
+ Some(expected_data_offset),
+ "data_offset should point to start of sample data in mdat"
+ );
+
+ // Verify that reading at that offset gives us the sample data
+ let actual_offset = expected_data_offset as usize - new_moof_size;
+ assert_eq!(
+ &mdat_bytes[actual_offset..actual_offset + 10],
+ &sample_data[..],
+ "Data at offset should match sample"
+ );
+ }
+
+ /// Standalone version of build_per_track_segment for testing without Fmp4 instance
+ fn build_per_track_segment_standalone(
+ mfhd: &Mfhd,
+ traf: &Traf,
+ global_mdat: &Bytes,
+ moof_size: usize,
+ ) -> (Bytes, Bytes) {
+ use mp4_atom::Encode;
+
+ let default_sample_size = traf.tfhd.default_sample_size.unwrap_or(0);
+
+ // Extract sample data for this track
+ let mut track_mdat_data = BytesMut::new();
+ let mut offset = traf.tfhd.base_data_offset.unwrap_or_default() as usize;
+
+ for trun in &traf.trun {
+ if let Some(data_offset) = trun.data_offset {
+ let base_offset = traf.tfhd.base_data_offset.unwrap_or_default() as usize;
+ let data_offset_usize = data_offset as usize;
+ // Calculate offset into mdat
+ offset = base_offset + data_offset_usize - moof_size - 8;
+ }
+
+ for entry in &trun.entries {
+ let size = entry.size.unwrap_or(default_sample_size) as usize;
+ if offset + size <= global_mdat.len() {
+ track_mdat_data.extend_from_slice(&global_mdat[offset..offset + size]);
+ }
+ offset += size;
+ }
+ }
+
+ // Clone and update traf
+ let mut new_traf = traf.clone();
+
+ // Calculate new moof size
+ let temp_moof = Moof {
+ mfhd: mfhd.clone(),
+ traf: vec![new_traf.clone()],
+ };
+ let mut temp_moof_bytes = BytesMut::new();
+ temp_moof.encode(&mut temp_moof_bytes).unwrap();
+ let new_moof_size = temp_moof_bytes.len();
+
+ // Update trun data_offsets
+ let mut current_offset_in_track_mdat: i32 = 0;
+ for trun in &mut new_traf.trun {
+ trun.data_offset = Some((new_moof_size as i32) + 8 + current_offset_in_track_mdat);
+ for entry in &trun.entries {
+ let size = entry.size.unwrap_or(default_sample_size);
+ current_offset_in_track_mdat += size as i32;
+ }
+ }
+
+ // Build final moof
+ let per_track_moof = Moof {
+ mfhd: mfhd.clone(),
+ traf: vec![new_traf],
+ };
+ let mut moof_bytes = BytesMut::new();
+ per_track_moof.encode(&mut moof_bytes).unwrap();
+
+ // Build mdat
+ let mdat_size = (8 + track_mdat_data.len()) as u32;
+ let mut mdat_bytes = BytesMut::new();
+ mdat_bytes.extend_from_slice(&mdat_size.to_be_bytes());
+ mdat_bytes.extend_from_slice(b"mdat");
+ mdat_bytes.extend_from_slice(&track_mdat_data);
+
+ (moof_bytes.freeze(), mdat_bytes.freeze())
+ }
+
+ /// Helper to decode a Moof from bytes
+ fn decode_moof(bytes: &Bytes) -> Moof {
+ use mp4_atom::Decode;
+ let mut cursor = std::io::Cursor::new(bytes);
+ Moof::decode(&mut cursor).expect("Failed to decode moof")
+ }
+}