feat(ffi): decode a raw group as media, for arrival-order reads

cpp/moq/include/moq/moq.hpp

@@ -70,8 +70,8 @@ using JsonStreamConsumer = MoqJsonStreamConsumer;
 using JsonStreamProducer = MoqJsonStreamProducer;
 using MediaCatalogConsumer = MoqMediaCatalogConsumer;
 using MediaCatalogProducer = MoqMediaCatalogProducer;
-using MediaContainerConsumer = MoqMediaContainerConsumer;
-using MediaContainerGroupConsumer = MoqMediaContainerGroupConsumer;
+using MediaTrackConsumer = MoqMediaTrackConsumer;
+using MediaGroupConsumer = MoqMediaGroupConsumer;
 using MediaContainerProducer = MoqMediaContainerProducer;
 using MediaContainerStreamProducer = MoqMediaContainerStreamProducer;
 using MediaTrackProducer = MoqMediaTrackProducer;
@@ -111,8 +111,8 @@ using FlateConfig = MoqFlateConfig;
 using Frame = MoqFrame;
 using JsonSnapshotConfig = MoqJsonSnapshotConfig;
 using JsonStreamConfig = MoqJsonStreamConfig;
-using MediaContainerConfig = MoqMediaContainerConfig;
-using MediaContainerGroupConfig = MoqMediaContainerGroupConfig;
+using MediaTrackConfig = MoqMediaTrackConfig;
+using MediaGroupConfig = MoqMediaGroupConfig;
 using MediaFrame = MoqMediaFrame;
 using OriginConfig = MoqOriginConfig;
 using ProtocolError = MoqProtocolError;

cpp/moq/test/doc-samples.hpp

@@ -28,7 +28,7 @@ inline void ok(moq::expected<void> result) {
 }
 
 inline std::shared_ptr<moq::Session> session;
-inline std::shared_ptr<moq::MediaContainerConsumer> media;
+inline std::shared_ptr<moq::MediaTrackConsumer> media;
 inline std::vector<uint8_t> opus_init;
 inline std::vector<uint8_t> packet;
 inline std::vector<uint8_t> rgba;

cpp/obs/src/moq-source.cpp

@@ -209,7 +209,7 @@ struct Track {
 	std::unique_ptr<AudioDecoder> audio_decoder;
 	moq::Container container;
 
-	std::shared_ptr<moq::MediaContainerConsumer> consumer;
+	std::shared_ptr<moq::MediaTrackConsumer> consumer;
 	std::optional<moq::Continuation> call;
 };
 
@@ -584,7 +584,7 @@ static std::string moq_source_track_name(const std::pair<const std::string, Rend
 
 static void moq_source_on_subscribed(struct moq_source *ctx, const std::shared_ptr<Connection> &conn,
 				     const std::shared_ptr<Track> &track,
-				     moq::expected<std::shared_ptr<moq::MediaContainerConsumer>> result);
+				     moq::expected<std::shared_ptr<moq::MediaTrackConsumer>> result);
 static void moq_source_read_track(struct moq_source *ctx, const std::shared_ptr<Connection> &conn,
 				  const std::shared_ptr<Track> &track);
 static void moq_source_on_frame(struct moq_source *ctx, const std::shared_ptr<Connection> &conn,
@@ -636,16 +636,15 @@ static void moq_source_on_resolved(struct moq_source *ctx, const std::shared_ptr
 		moq_source_discard_candidate(conn, track);
 		return;
 	}
-	track->call =
-		moq::MediaContainerConsumer::subscribe(*result, {track->name, track->container})
-			.then(ctx->worker.Executor(),
-			      moq_source_track_current<moq::expected<std::shared_ptr<moq::MediaContainerConsumer>>>(
-				      ctx, conn, track, moq_source_on_subscribed));
+	track->call = moq::MediaTrackConsumer::subscribe(*result, {track->name, track->container})
+			      .then(ctx->worker.Executor(),
+				    moq_source_track_current<moq::expected<std::shared_ptr<moq::MediaTrackConsumer>>>(
+					    ctx, conn, track, moq_source_on_subscribed));
 }
 
 static void moq_source_on_subscribed(struct moq_source *ctx, const std::shared_ptr<Connection> &conn,
 				     const std::shared_ptr<Track> &track,
-				     moq::expected<std::shared_ptr<moq::MediaContainerConsumer>> result)
+				     moq::expected<std::shared_ptr<moq::MediaTrackConsumer>> result)
 {
 	if (!result) {
 		LOG_ERROR("Failed to subscribe to %s track: %s", track->kind, result.error().to_string().c_str());

cpp/obs/test/moq-output-test.cpp

@@ -432,9 +432,9 @@ int main()
 		CHECK(catalog.has_value());
 		if (catalog) {
 			const auto &[name, rendition] = *catalog->video.begin();
-			auto media = TestOk(
-				moq::MediaContainerConsumer::subscribe(broadcast, {name, rendition.container}).get(),
-				"container consumer");
+			auto media =
+				TestOk(moq::MediaTrackConsumer::subscribe(broadcast, {name, rendition.container}).get(),
+				       "container consumer");
 			// Read a frame first, so the relay is subscribed before the last one is written.
 			auto next = media->next();
 			CHECK(next.wait_for(std::chrono::seconds(10)) == std::future_status::ready);

dart/moq/lib/media.dart

@@ -16,10 +16,10 @@ typedef ContainerProducer = MoqMediaContainerProducer;
 typedef ContainerStreamProducer = MoqMediaContainerStreamProducer;
 
 /// The read side of a media track: yields frames with codec metadata in decode order.
-typedef ContainerConsumer = MoqMediaContainerConsumer;
+typedef TrackConsumer = MoqMediaTrackConsumer;
 
 /// A finite fetched media group: yields container-decoded frames until the group ends.
-typedef ContainerGroupConsumer = MoqMediaContainerGroupConsumer;
+typedef GroupConsumer = MoqMediaGroupConsumer;
 
 /// The read side of a broadcast's catalog: yields updates as the set of tracks changes.
 typedef CatalogConsumer = MoqMediaCatalogConsumer;
@@ -76,10 +76,10 @@ typedef Named = NamedMoqMediaTarget;
 typedef Requested = RequestedMoqMediaTarget;
 
 /// A track name, container, and live delivery options.
-typedef ContainerConfig = MoqMediaContainerConfig;
+typedef TrackConfig = MoqMediaTrackConfig;
 
 /// A fetched group name, sequence, container, and delivery options.
-typedef ContainerGroupConfig = MoqMediaContainerGroupConfig;
+typedef GroupConfig = MoqMediaGroupConfig;
 
 /// The packaging advertised for a media track.
 typedef Container = MoqContainer;