moq-mux: decouple importers from the catalog, split byte-parsing into per-codec splitters, and make importers pure frame publishers

kt/moq/src/jvmAndAndroidMain/kotlin/dev/moq/Aliases.kt

@@ -24,6 +24,7 @@ typealias Announcement = uniffi.moq.MoqAnnouncement
 typealias BroadcastProducer = uniffi.moq.MoqBroadcastProducer
 typealias BroadcastConsumer = uniffi.moq.MoqBroadcastConsumer
 typealias TrackProducer = uniffi.moq.MoqTrackProducer
+typealias TrackRequest = uniffi.moq.MoqTrackRequest
 typealias TrackConsumer = uniffi.moq.MoqTrackConsumer
 typealias GroupProducer = uniffi.moq.MoqGroupProducer
 typealias GroupConsumer = uniffi.moq.MoqGroupConsumer

kt/moq/src/jvmAndAndroidMain/kotlin/dev/moq/Flows.kt

@@ -19,7 +19,7 @@ import uniffi.moq.MoqGroupConsumer
 import uniffi.moq.MoqMediaConsumer
 import uniffi.moq.MoqOriginConsumer
 import uniffi.moq.MoqTrackConsumer
-import uniffi.moq.MoqTrackProducer
+import uniffi.moq.MoqTrackRequest
 
 /**
  * Stream of catalog updates. Terminates when the underlying track ends.
@@ -95,7 +95,7 @@ fun MoqTrackConsumer.groupsAsArrived(): Flow<MoqGroupConsumer> = flow {
 }
 
 /** Stream of tracks requested by subscribers. */
-fun MoqBroadcastDynamic.requestedTracks(): Flow<MoqTrackProducer> = flow {
+fun MoqBroadcastDynamic.requestedTracks(): Flow<MoqTrackRequest> = flow {
     while (true) {
         currentCoroutineContext().ensureActive()
         emit(requestedTrack())

py/moq-rs/moq/__init__.py

@@ -16,6 +16,7 @@
     MediaProducer,
     MediaStreamProducer,
     TrackProducer,
+    TrackRequest,
 )
 from .server import Request, Server, Transport
 from .session import Session
@@ -81,6 +82,7 @@
     "TrackConsumer",
     "TrackInfo",
     "TrackProducer",
+    "TrackRequest",
     "Transport",
     "Video",
     "connect",

py/moq-rs/moq/publish.py

@@ -12,6 +12,7 @@
     MoqMediaProducer,
     MoqMediaStreamProducer,
     MoqTrackProducer,
+    MoqTrackRequest,
 )
 
 from .types import AudioEncoderInput, AudioEncoderOutput, AudioFrame, Subscription, TrackInfo
@@ -137,6 +138,30 @@ def finish(self) -> None:
         self._inner.finish()
 
 
+class TrackRequest:
+    """A subscriber-requested track that hasn't been accepted yet.
+
+    Accept it for raw writes, hand it to :meth:`BroadcastProducer.publish_media_on_track`
+    to publish media (the importer accepts it), or abort it to reject the subscriber.
+    """
+
+    def __init__(self, inner: MoqTrackRequest) -> None:
+        self._inner = inner
+
+    @property
+    def name(self) -> str:
+        """The requested track name."""
+        return self._inner.name()
+
+    def accept(self) -> TrackProducer:
+        """Accept the request as a raw track."""
+        return TrackProducer(self._inner.accept(None))
+
+    def abort(self, error_code: int) -> None:
+        """Reject the request with an application error code."""
+        self._inner.abort(error_code)
+
+
 class AudioProducer:
     """Publish raw PCM and let libopus encode it on the way out.
 
@@ -170,11 +195,11 @@ def __init__(self, inner: MoqBroadcastDynamic) -> None:
     def __aiter__(self):
         return self
 
-    async def __anext__(self) -> TrackProducer:
+    async def __anext__(self) -> TrackRequest:
         return await self.requested_track()
 
-    async def requested_track(self) -> TrackProducer:
-        return TrackProducer(await self._inner.requested_track())
+    async def requested_track(self) -> TrackRequest:
+        return TrackRequest(await self._inner.requested_track())
 
     def cancel(self) -> None:
         self._inner.cancel()
@@ -193,8 +218,8 @@ def dynamic(self) -> BroadcastDynamic:
     def publish_media(self, format: str, init: bytes) -> MediaProducer:
         return MediaProducer(self._inner.publish_media(format, init))
 
-    def publish_media_on_track(self, track: TrackProducer, format: str, init: bytes) -> MediaProducer:
-        return MediaProducer(self._inner.publish_media_on_track(track._inner, format, init))
+    def publish_media_on_track(self, request: TrackRequest, format: str, init: bytes) -> MediaProducer:
+        return MediaProducer(self._inner.publish_media_on_track(request._inner, format, init))
 
     def publish_media_stream(self, format: str) -> MediaStreamProducer:
         """Publish a media track fed by a raw byte stream (unknown frame

py/moq-rs/tests/test_local.py

@@ -259,13 +259,14 @@ async def test_dynamic_track_request():
     dynamic = broadcast.dynamic()
     consumer = broadcast.consume()
 
-    # The request is accepted by the first producer op (write_frame below), so the
-    # subscribe stays pending until then; run it concurrently.
+    # The subscribe stays pending until the request is accepted below; run it concurrently.
     subscribe = asyncio.create_task(consumer.subscribe_track("events"))
 
-    track = await asyncio.wait_for(dynamic.requested_track(), timeout=5.0)
-    assert track.name == "events"
+    request = await asyncio.wait_for(dynamic.requested_track(), timeout=5.0)
+    assert request.name == "events"
 
+    # Accept the request as a raw track (which unblocks the subscribe), then write.
+    track = request.accept()
     payload = b"hello dynamic track"
     track.write_frame(payload)
 

rs/libmoq/src/api.rs

@@ -81,6 +81,92 @@ pub struct moq_announced {
 	pub active: bool,
 }
 
+/// A snapshot of connection statistics, filled in by [moq_session_stats].
+///
+/// Each metric has a `*_valid` flag: when `false`, the matching value is meaningless because
+/// the transport backend doesn't report it (a `false` flag is NOT the same as a zero value).
+/// Native QUIC reports every metric; the browser WebTransport reports few or none. Initialize
+/// the struct to zero before the call; [moq_session_stats] overwrites every field.
+#[repr(C)]
+#[allow(non_camel_case_types)]
+pub struct moq_connection_stats {
+	/// Smoothed round-trip time, in microseconds.
+	pub rtt_us: u64,
+	pub rtt_valid: bool,
+
+	/// Estimated send bandwidth from the congestion controller, in bits per second.
+	pub send_rate_bps: u64,
+	pub send_rate_valid: bool,
+
+	/// Estimated receive bandwidth from MoQ PROBE, in bits per second.
+	pub recv_rate_bps: u64,
+	pub recv_rate_valid: bool,
+
+	/// Total bytes sent, including retransmissions and overhead.
+	pub bytes_sent: u64,
+	pub bytes_sent_valid: bool,
+
+	/// Total bytes received, including duplicates and overhead.
+	pub bytes_received: u64,
+	pub bytes_received_valid: bool,
+
+	/// Total bytes lost (detected via retransmission or acknowledgement).
+	pub bytes_lost: u64,
+	pub bytes_lost_valid: bool,
+
+	/// Total datagrams sent.
+	pub packets_sent: u64,
+	pub packets_sent_valid: bool,
+
+	/// Total datagrams received.
+	pub packets_received: u64,
+	pub packets_received_valid: bool,
+
+	/// Total datagrams detected as lost.
+	pub packets_lost: u64,
+	pub packets_lost_valid: bool,
+}
+
+impl From<&moq_net::ConnectionStats> for moq_connection_stats {
+	fn from(stats: &moq_net::ConnectionStats) -> Self {
+		// An Option<u64> becomes a (value, valid) pair; absent metrics report 0/false.
+		fn split(value: Option<u64>) -> (u64, bool) {
+			(value.unwrap_or(0), value.is_some())
+		}
+
+		let (rtt_us, rtt_valid) = split(stats.rtt.map(|d| d.as_micros() as u64));
+		let (send_rate_bps, send_rate_valid) = split(stats.estimated_send_rate);
+		let (recv_rate_bps, recv_rate_valid) = split(stats.estimated_recv_rate);
+		let (bytes_sent, bytes_sent_valid) = split(stats.bytes_sent);
+		let (bytes_received, bytes_received_valid) = split(stats.bytes_received);
+		let (bytes_lost, bytes_lost_valid) = split(stats.bytes_lost);
+		let (packets_sent, packets_sent_valid) = split(stats.packets_sent);
+		let (packets_received, packets_received_valid) = split(stats.packets_received);
+		let (packets_lost, packets_lost_valid) = split(stats.packets_lost);
+
+		Self {
+			rtt_us,
+			rtt_valid,
+			send_rate_bps,
+			send_rate_valid,
+			recv_rate_bps,
+			recv_rate_valid,
+			bytes_sent,
+			bytes_sent_valid,
+			bytes_received,
+			bytes_received_valid,
+			bytes_lost,
+			bytes_lost_valid,
+			packets_sent,
+			packets_sent_valid,
+			packets_received,
+			packets_received_valid,
+			packets_lost,
+			packets_lost_valid,
+		}
+	}
+}
+
 /// Initialize the library with a log level.
 ///
 /// This should be called before any other functions.
@@ -195,6 +281,29 @@ pub extern "C" fn moq_session_close(session: u32) -> i32 {
 	})
 }
 
+/// Snapshot the current connection statistics for a session.
+///
+/// Fills `dst` with a point-in-time view of the underlying QUIC/WebTransport connection
+/// (RTT, bandwidth estimates, byte/packet counters). Each metric carries a `*_valid` flag
+/// since availability depends on the transport backend; see [moq_connection_stats].
+///
+/// Returns zero on success, or a negative code on failure: the session handle is unknown, or
+/// the session is currently reconnecting and has no live connection (in which case `dst` is
+/// left untouched). Safe to call repeatedly to poll stats over the life of the session.
+///
+/// # Safety
+/// - The caller must ensure that `dst` is a valid pointer to a [moq_connection_stats] struct.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn moq_session_stats(session: u32, dst: *mut moq_connection_stats) -> i32 {
+	ffi::enter(move || {
+		let session = ffi::parse_id(session)?;
+		let dst = unsafe { dst.as_mut() }.ok_or(Error::InvalidPointer)?;
+		let stats = State::lock().session.stats(session)?;
+		*dst = moq_connection_stats::from(&stats);
+		Ok(())
+	})
+}
+
 /// Create an origin for publishing broadcasts.
 ///
 /// Origins contain any number of broadcasts addressed by path.

rs/libmoq/src/publish.rs

@@ -1,17 +1,23 @@
-use std::str::FromStr;
-
-use bytes::Buf;
 use moq_mux::import;
 
 use crate::{Error, Id, NonZeroSlab};
 
+/// A media importer fed whole chunks: either a single codec track or a container
+/// that may publish several tracks. The format string picks which at creation.
+enum Media {
+	// Boxed because the codec splitters/imports make this variant much larger
+	// than the (already boxed) container one.
+	Track(Box<import::Track>),
+	Container(import::Container),
+}
+
 #[derive(Default)]
 pub struct Publish {
 	/// Active broadcast producers for publishing.
 	broadcasts: NonZeroSlab<(moq_net::BroadcastProducer, moq_mux::catalog::Producer)>,
 
 	/// Active media encoders/decoders for publishing.
-	media: NonZeroSlab<import::Framed>,
+	media: NonZeroSlab<Media>,
 
 	/// Raw track producers (no media/container/catalog framing).
 	tracks: NonZeroSlab<moq_net::TrackProducer>,
@@ -52,36 +58,48 @@ impl Publish {
 		Ok(())
 	}
 
-	pub fn media_ordered(&mut self, broadcast: Id, format: &str, mut init: &[u8]) -> Result<Id, Error> {
+	pub fn media_ordered(&mut self, broadcast: Id, format: &str, init: &[u8]) -> Result<Id, Error> {
 		let (broadcast, catalog) = self.broadcasts.get(broadcast).ok_or(Error::BroadcastNotFound)?;
 
-		let format = import::FramedFormat::from_str(format).map_err(|_| Error::UnknownFormat(format.to_string()))?;
-		let decoder = import::Framed::new(broadcast.clone(), catalog.clone(), format, &mut init)?;
-
-		let id = self.media.insert(decoder)?;
+		// A container may publish several tracks; a single codec fills one reserved
+		// track. Try the container first so a codec format doesn't reserve a stray
+		// track on the way to being recognized.
+		let media = match import::Container::new(broadcast.clone(), catalog.clone(), format, init) {
+			Ok(container) => Media::Container(container),
+			Err(moq_mux::Error::UnknownFormat(_)) => {
+				let mut broadcast = broadcast.clone();
+				let name = broadcast.unique_name(&format!(".{format}"));
+				let request = broadcast.reserve_track(name)?;
+				match import::Track::new(request, catalog.clone(), format, init) {
+					Ok(track) => Media::Track(Box::new(track)),
+					Err(moq_mux::Error::UnknownFormat(_)) => return Err(Error::UnknownFormat(format.to_string())),
+					Err(err) => return Err(err.into()),
+				}
+			}
+			Err(err) => return Err(err.into()),
+		};
+
+		let id = self.media.insert(media)?;
 		Ok(id)
 	}
 
-	pub fn media_frame(
-		&mut self,
-		media: Id,
-		mut data: &[u8],
-		timestamp: hang::container::Timestamp,
-	) -> Result<(), Error> {
+	pub fn media_frame(&mut self, media: Id, data: &[u8], timestamp: hang::container::Timestamp) -> Result<(), Error> {
 		let media = self.media.get_mut(media).ok_or(Error::MediaNotFound)?;
 
-		media.decode_frame(&mut data, Some(timestamp))?;
-
-		if data.has_remaining() {
-			return Err(Error::BufferNotConsumed);
+		match media {
+			Media::Track(track) => track.decode(data, Some(timestamp))?,
+			Media::Container(container) => container.decode(data)?,
 		}
 
 		Ok(())
 	}
 
 	pub fn media_close(&mut self, media: Id) -> Result<(), Error> {
-		let mut decoder = self.media.remove(media).ok_or(Error::MediaNotFound)?;
-		decoder.finish()?;
+		let mut media = self.media.remove(media).ok_or(Error::MediaNotFound)?;
+		match &mut media {
+			Media::Track(track) => track.finish()?,
+			Media::Container(container) => container.finish()?,
+		}
 		Ok(())
 	}