fix: preserve DASH render startup

Author: mondain

src/live_dash_ingest.cpp

@@ -506,10 +506,21 @@ LiveObject LiveDashIngestSession::build_catalog_locked() {
                 << "\"id\":" << track.track_id << ','
                 << "\"role\":\"" << role_for_handler(track.handler_type) << "\","
                 << "\"packaging\":\"cmaf\","
+                << "\"renderGroup\":1,"
                 << "\"isLive\":true";
         if (!track.codec.empty()) {
             catalog << ",\"codec\":\"" << json_escape(track.codec) << "\"";
         }
+        if (track.handler_type == "vide") {
+            catalog << ",\"width\":" << track.width
+                    << ",\"height\":" << track.height;
+            if (track.frame_rate > 0.0) {
+                catalog << ",\"frameRate\":" << std::setprecision(6) << track.frame_rate;
+            }
+        } else if (track.handler_type == "soun") {
+            catalog << ",\"sampleRate\":" << track.sample_rate
+                    << ",\"channelCount\":" << track.channel_count;
+        }
         if (!registered.init_data_base64.empty()) {
             catalog << ",\"initData\":\"" << registered.init_data_base64 << "\"";
         }

src/transport/moqt_session.cpp

@@ -4597,6 +4597,12 @@ TransportStatus MoqtSession::publish_live_objects(const openmoq::publisher::Live
     std::optional<std::chrono::steady_clock::time_point> object_pacing_start;
     std::optional<std::uint64_t> object_first_media_time_us;
     bool live_object_catalog_sent = !alias_by_track.contains("catalog");
+    const bool has_media_tracks = std::any_of(alias_by_track.begin(), alias_by_track.end(),
+                                              [](const auto& entry) { return entry.first != "catalog"; });
+    const auto has_media_subscription = [&]() {
+        return std::any_of(subscribed_tracks.begin(), subscribed_tracks.end(),
+                           [](const std::string& track_name) { return track_name != "catalog"; });
+    };
     const auto await_subscribe_deadline = std::chrono::steady_clock::now() + subscriber_timeout_;
     while (!source_eof) {
         if (stop_requested_.load(std::memory_order_acquire)) {
@@ -4611,7 +4617,11 @@ TransportStatus MoqtSession::publish_live_objects(const openmoq::publisher::Live
         bool read_fin = false;
         const bool waiting_for_first_subscription =
             !auto_forward_ && active_subscriptions.empty() && subscribed_tracks.empty();
-        const auto read_timeout = waiting_for_first_subscription && !uses_request_streams(draft_version)
+        const bool waiting_for_media_subscription =
+            !auto_forward_ && live_object_catalog_sent && has_media_tracks && !has_media_subscription();
+        const bool waiting_for_required_subscription =
+            waiting_for_first_subscription || waiting_for_media_subscription;
+        const auto read_timeout = waiting_for_required_subscription && !uses_request_streams(draft_version)
                                       ? subscriber_timeout_
                                       : std::chrono::milliseconds(0);
         const TransportStatus read_status =
@@ -4621,7 +4631,8 @@ TransportStatus MoqtSession::publish_live_objects(const openmoq::publisher::Live
             control_fin = read_fin;
         } else if (read_status.message == "timed out waiting for stream data" ||
                    read_status.message == "no queued read for stream") {
-            if (waiting_for_first_subscription && std::chrono::steady_clock::now() >= await_subscribe_deadline) {
+            if (waiting_for_required_subscription &&
+                std::chrono::steady_clock::now() >= await_subscribe_deadline) {
                 break;
             }
         } else {
@@ -4643,6 +4654,9 @@ TransportStatus MoqtSession::publish_live_objects(const openmoq::publisher::Live
         if (!auto_forward_ && subscribed_tracks.empty()) {
             continue;
         }
+        if (!auto_forward_ && live_object_catalog_sent && has_media_tracks && !has_media_subscription()) {
+            continue;
+        }
 
         std::optional<openmoq::publisher::LiveObject> next = source.next_object();
         if (!next.has_value()) {

tests/live_dash_ingest_test.cpp

@@ -273,8 +273,14 @@ int main() {
         ok &= expect(catalog.has_value() && catalog->track_name == "catalog",
                      "expected catalog object for initData test");
         if (catalog.has_value()) {
-            ok &= expect(as_string(catalog->payload).find("\"initData\":\"") != std::string::npos,
+            const std::string catalog_text = as_string(catalog->payload);
+            ok &= expect(catalog_text.find("\"initData\":\"") != std::string::npos,
                          "expected catalog to embed base64 initData for the track");
+            ok &= expect(catalog_text.find("\"renderGroup\":1") != std::string::npos,
+                         "expected DASH catalog track to declare its render group");
+            ok &= expect(catalog_text.find("\"width\":320") != std::string::npos &&
+                             catalog_text.find("\"height\":240") != std::string::npos,
+                         "expected DASH catalog video dimensions for renderer selection");
         }
     }
 

tests/moqt_session_test.cpp

@@ -2530,16 +2530,24 @@ int main() {
             encode_publish_namespace_ok_message(DraftVersion::kDraft16, 0));
         dash_live_transport.reads[0].push_back(
             encode_subscribe_message(
-                1, kTestTrackNamespace, "video0_vide_1", 0, DraftVersion::kDraft16));
+                1, kTestTrackNamespace, "catalog", 0, DraftVersion::kDraft16));
+        dash_live_transport.reads[0].push_back({});
+        dash_live_transport.reads[0].push_back(
+            encode_subscribe_message(
+                3, kTestTrackNamespace, "video0_vide_1", 0, DraftVersion::kDraft16));
         // Keep the mock control stream open while each queued source object is considered.
         for (int i = 0; i < 4; ++i) {
             dash_live_transport.reads[0].push_back({});
         }
 
-        bool subscribe_read = false;
+        bool catalog_subscribe_read = false;
+        bool media_subscribe_read = false;
         dash_live_transport.on_read = [&](MockTransport& transport, std::uint64_t stream_id) {
             if (stream_id == 0 && transport.read_count >= 3) {
-                subscribe_read = true;
+                catalog_subscribe_read = true;
+            }
+            if (stream_id == 0 && transport.read_count >= 5) {
+                media_subscribe_read = true;
             }
         };
 
@@ -2551,6 +2559,7 @@ int main() {
         };
         std::size_t object_index = 0;
         bool consumed_before_subscribe = false;
+        bool media_consumed_before_media_subscribe = false;
         LiveObjectSource source{
             .tracks = {
                 LiveTrack{.track_name = "catalog"},
@@ -2559,7 +2568,9 @@ int main() {
                 LiveTrack{.track_name = "video2_vide_3"},
             },
             .next_object = [&]() -> std::optional<LiveObject> {
-                consumed_before_subscribe = consumed_before_subscribe || !subscribe_read;
+                consumed_before_subscribe = consumed_before_subscribe || !catalog_subscribe_read;
+                media_consumed_before_media_subscribe =
+                    media_consumed_before_media_subscribe || (object_index > 0 && !media_subscribe_read);
                 if (object_index >= objects.size()) {
                     return std::nullopt;
                 }
@@ -2578,11 +2589,13 @@ int main() {
         ok &= expect(status.ok, "expected FFmpeg-style DASH session connect to succeed");
         status = dash_live_session.publish_live_objects(source, DraftVersion::kDraft16);
         ok &= expect(status.ok, "expected FFmpeg-style DASH publish to enter await-subscribe mode");
-        ok &= expect(subscribe_read && !consumed_before_subscribe,
+        ok &= expect(catalog_subscribe_read && media_subscribe_read && !consumed_before_subscribe,
                      "expected FFmpeg-style DASH media consumption to wait for SUBSCRIBE");
+        ok &= expect(!media_consumed_before_media_subscribe,
+                     "expected catalog-first subscription to preserve queued media until media SUBSCRIBE");
         ok &= expect(control_message_count(dash_live_transport, 0x1d) == 4,
                      "expected catalog plus three FFmpeg-style DASH tracks to be published");
-        ok &= expect(control_message_count(dash_live_transport, 0x04) == 1,
+        ok &= expect(control_message_count(dash_live_transport, 0x04) == 2,
                      "expected FFmpeg-style DASH subscriber to receive SUBSCRIBE_OK");
         ok &= expect(dash_live_session.publish_stats().objects_published == 2,
                      "expected catalog and subscribed FFmpeg-style DASH representation only");