Add configurable publish namespace

Author: mondain

.gitignore

@@ -1,5 +1,6 @@
 # Build output
 /build/
+/build-*/
 /out/
 /cmake-build-*/
 
@@ -17,3 +18,5 @@ Testing/
 # Tooling
 compile_commands.json
 
+# Local test artifacts
+/tmp-*.mp4

README.md

@@ -22,14 +22,15 @@ It is buildable and testable today, but it is not yet a full interoperable MOQT
 - Isolates MOQT draft-version mapping from the media packaging code
 - Builds a picoquic-backed QUIC transport path when local `picoquic` and `picotls` checkouts are available
 - Publishes a draft-aware control stream plus per-object streams in the current session layer
+- Supports a configurable published track namespace for relay and interop testing
 
 ## Current limitations
 
-- No OpenMOQ relay interoperability coverage yet
+- External relay interoperability is still incomplete
 - Progressive MP4 remux support is intentionally narrow
 - Edit lists, richer interleaving cases, and broader timing edge cases are not fully handled yet
 - The current remux path synthesizes fragments from `stbl` sample tables but does not attempt a full general-purpose MP4 muxer implementation
-- The current MOQT control stream is still a contribution-oriented session mapping, not a finalized interoperable draft wire implementation
+- Current Cloudflare relay tests complete setup and namespace announcement, but do not yet result in inbound subscriptions
 
 ## Design overview
 
@@ -124,7 +125,7 @@ This covers:
 - fragmented MP4 packaging
 - progressive MP4 remux into CMAF-style objects
 - MOQT setup encoding and decoding
-- binary publish control/object sequencing
+- binary namespace announcement plus subscribe-serving control/object sequencing
 - QUIC varint boundary coverage
 
 ### Picoquic loopback smoke test
@@ -170,19 +171,20 @@ To attempt a live publish against a relay:
 ```bash
 OPENMOQ_PICOQUIC_TRACE=1 ./build/openmoq-publisher \
   --input sample.mp4 \
-  --endpoint moqt://moq-relay.red5.net:8443/moq \
+  --endpoint moqt://interop-relay.cloudflare.mediaoverquic.com:443/moq \
+  --namespace interop \
   --insecure
 ```
 
 Current status as of March 12, 2026:
 
-- QUIC handshake succeeds against `moq-relay.red5.net:8443`
-- the client sends `CLIENT_SETUP`
-- the client does not currently receive `SERVER_SETUP`
-- the publish attempt times out waiting for control-stream data
-- repeated tests against that relay have also been reported to crash the relay process
+- QUIC handshake succeeds against `draft-14.cloudflare.mediaoverquic.com:443` and `interop-relay.cloudflare.mediaoverquic.com:443`
+- `CLIENT_SETUP` succeeds and the client prints the negotiated connection ID to stdout after setup
+- `PUBLISH_NAMESPACE` is accepted with `PUBLISH_NAMESPACE_OK`
+- the current client then waits for inbound `SUBSCRIBE_NAMESPACE` / `SUBSCRIBE`
+- those Cloudflare endpoints did not issue subscriptions during these tests, so the publish attempt timed out waiting for control-stream data
 
-Because of that, treat the external relay path as unsafe for routine testing until setup interoperability is resolved.
+The older `moq-relay.red5.net:8443` endpoint behaved worse in earlier testing: setup did not complete reliably, and repeated malformed-control testing was reported to crash the relay. Prefer the Cloudflare endpoints for routine interop checks.
 
 ### Optional picoquic smoke test
 
@@ -226,17 +228,20 @@ Transport-oriented CLI flags are also present now:
 ./build/openmoq-publisher \
   --input sample.mp4 \
   --endpoint localhost:4433 \
+  --namespace media \
   --alpn moq-00 \
   --insecure
 ```
 
 Current status:
 
 - the packaging pipeline is fully usable today
-- the session layer now emits typed control messages for setup, namespace publication, and track publication
+- the session layer now emits typed control messages for setup, namespace publication, and subscription servicing
 - `--endpoint` now enters the real picoquic-backed transport path when the project is built with local picoquic and picotls support
 - the local picoquic loopback handshake works, including object publication over QUIC streams
-- interoperability against an external OpenMOQ-capable endpoint is still the next transport milestone
+- `--namespace` lets you choose the advertised track namespace during transport tests
+- after setup completes, the CLI prints `connection_id=<hex>` to stdout
+- interoperability against external relays is partially working at setup and namespace announce, but not yet at end-to-end subscription delivery
 
 ## Creating Fragmented MP4 with FFmpeg
 

include/openmoq/publisher/cli_options.h

@@ -15,6 +15,7 @@ struct CliOptions {
     std::optional<transport::EndpointConfig> endpoint;
     transport::TlsConfig tls;
     DraftVersion draft_version = DraftVersion::kDraft14;
+    std::string track_namespace = "media";
     bool dump_plan = false;
 };
 

include/openmoq/publisher/transport/moqt_session.h

@@ -13,20 +13,19 @@ namespace openmoq::publisher::transport {
 
 class MoqtSession {
 public:
-    explicit MoqtSession(PublisherTransport& transport);
+    explicit MoqtSession(PublisherTransport& transport, std::string track_namespace = "media");
 
     TransportStatus connect(const EndpointConfig& endpoint, const TlsConfig& tls);
     TransportStatus publish(const openmoq::publisher::PublishPlan& plan);
     TransportStatus close(std::uint64_t application_error_code = 0);
 
 private:
-    static constexpr std::string_view kDefaultTrackNamespace = "media";
-
     TransportStatus ensure_setup(openmoq::publisher::DraftVersion draft);
     TransportStatus ensure_control_stream();
     TransportStatus write_frame(std::uint64_t stream_id, std::span<const std::uint8_t> frame, bool fin);
 
     PublisherTransport& transport_;
+    std::string track_namespace_;
     std::optional<EndpointConfig> endpoint_;
     std::uint64_t control_stream_id_ = 0;
     std::uint64_t peer_max_request_id_ = 0;

src/cli_options.cpp

@@ -84,6 +84,8 @@ CliOptions parse_cli_options(int argc, char** argv) {
             options.tls.insecure_skip_verify = true;
         } else if (argument == "--draft") {
             options.draft_version = parse_draft(require_value("--draft"));
+        } else if (argument == "--namespace") {
+            options.track_namespace = std::string(require_value("--namespace"));
         } else if (argument == "--emit-dir") {
             options.emit_dir = std::filesystem::path(require_value("--emit-dir"));
         } else if (argument == "--dump-plan") {
@@ -102,13 +104,16 @@ CliOptions parse_cli_options(int argc, char** argv) {
     if (options.endpoint.has_value() && options.endpoint->host.empty()) {
         throw std::runtime_error("--alpn requires --endpoint to be provided first");
     }
+    if (options.track_namespace.empty()) {
+        throw std::runtime_error("--namespace must not be empty");
+    }
 
     return options;
 }
 
 std::string build_usage(const char* argv0) {
     return std::string("Usage: ") + argv0 +
-           " --input <mp4> [--draft 14|16] [--dump-plan] [--emit-dir <dir>]"
+           " --input <mp4> [--draft 14|16] [--namespace <value>] [--dump-plan] [--emit-dir <dir>]"
            " [--endpoint host:port|moqt://host:port/path] [--alpn value]"
            " [--cert file] [--key file] [--ca file] [--insecure]";
 }

src/main.cpp

@@ -30,7 +30,7 @@ int main(int argc, char** argv) {
 
             const PublishPlan materialized_plan = materialize_publish_plan(plan, parsed_mp4.bytes);
             PicoquicClient transport;
-            MoqtSession session(transport);
+            MoqtSession session(transport, options.track_namespace);
 
             TransportStatus status = session.connect(*options.endpoint, options.tls);
             if (!status.ok) {

src/transport/moqt_session.cpp

@@ -15,8 +15,6 @@ namespace openmoq::publisher::transport {
 
 namespace {
 
-constexpr std::string_view kDefaultTrackNamespaceValue = "media";
-
 bool control_message_complete(std::span<const std::uint8_t> bytes, std::size_t& message_size) {
     return next_control_message(bytes, message_size);
 }
@@ -183,14 +181,15 @@ TransportStatus serve_subscriptions(PublisherTransport& transport,
                                     std::uint64_t control_stream_id,
                                     const openmoq::publisher::PublishPlan& plan,
                                     const std::map<std::string, PublishedTrack>& tracks_by_name,
-                                    openmoq::publisher::DraftVersion draft) {
+                                    openmoq::publisher::DraftVersion draft,
+                                    std::string_view track_namespace) {
     std::vector<std::uint8_t> buffer;
     std::set<std::uint64_t> completed_request_ids;
     bool fin = false;
     bool served_any_subscription = false;
     NamespaceMessage namespace_message{
         .draft = draft,
-        .track_namespace = std::string(kDefaultTrackNamespaceValue),
+        .track_namespace = std::string(track_namespace),
         .request_id = 0,
     };
 
@@ -236,7 +235,7 @@ TransportStatus serve_subscriptions(PublisherTransport& transport,
                 if (!decode_subscribe_namespace_message(message_bytes, subscribe_namespace)) {
                     return TransportStatus::failure("received invalid SUBSCRIBE_NAMESPACE");
                 }
-                if (!namespace_prefix_matches(subscribe_namespace.track_namespace_prefix, kDefaultTrackNamespaceValue)) {
+                if (!namespace_prefix_matches(subscribe_namespace.track_namespace_prefix, track_namespace)) {
                     return TransportStatus::failure("peer requested unsupported namespace prefix");
                 }
                 const TransportStatus write_status =
@@ -255,7 +254,7 @@ TransportStatus serve_subscriptions(PublisherTransport& transport,
                 if (!decode_subscribe_message(message_bytes, subscribe)) {
                     return TransportStatus::failure("received invalid SUBSCRIBE");
                 }
-                if (!namespace_matches(subscribe.track_namespace, kDefaultTrackNamespaceValue)) {
+                if (!namespace_matches(subscribe.track_namespace, track_namespace)) {
                     return TransportStatus::failure("peer requested unsupported track namespace");
                 }
 
@@ -338,7 +337,8 @@ TransportStatus serve_subscriptions(PublisherTransport& transport,
 
 }  // namespace
 
-MoqtSession::MoqtSession(PublisherTransport& transport) : transport_(transport) {}
+MoqtSession::MoqtSession(PublisherTransport& transport, std::string track_namespace)
+    : transport_(transport), track_namespace_(std::move(track_namespace)) {}
 
 TransportStatus MoqtSession::connect(const EndpointConfig& endpoint, const TlsConfig& tls) {
     endpoint_ = endpoint;
@@ -372,7 +372,7 @@ TransportStatus MoqtSession::publish(const openmoq::publisher::PublishPlan& plan
 
     NamespaceMessage namespace_message{
         .draft = plan.draft.version,
-        .track_namespace = std::string(kDefaultTrackNamespace),
+        .track_namespace = track_namespace_,
         .request_id = 0,
     };
     status = write_frame(control_stream_id_, encode_namespace_message(namespace_message), false);
@@ -390,7 +390,7 @@ TransportStatus MoqtSession::publish(const openmoq::publisher::PublishPlan& plan
         tracks_by_name.emplace(track.name, track);
     }
 
-    return serve_subscriptions(transport_, control_stream_id_, plan, tracks_by_name, plan.draft.version);
+    return serve_subscriptions(transport_, control_stream_id_, plan, tracks_by_name, plan.draft.version, track_namespace_);
 }
 
 TransportStatus MoqtSession::close(std::uint64_t application_error_code) {

tests/moqt_session_test.cpp

@@ -141,13 +141,13 @@ std::vector<std::uint8_t> encode_publish_namespace_ok_message(std::uint64_t requ
     return message;
 }
 
-std::vector<std::uint8_t> encode_subscribe_namespace_message(std::uint64_t request_id) {
+std::vector<std::uint8_t> encode_subscribe_namespace_message(std::uint64_t request_id, std::string_view track_namespace) {
     std::vector<std::uint8_t> payload = encode_varint(request_id);
     const std::vector<std::uint8_t> tuple_len = encode_varint(1);
-    const std::vector<std::uint8_t> component_len = encode_varint(5);
+    const std::vector<std::uint8_t> component_len = encode_varint(track_namespace.size());
     payload.insert(payload.end(), tuple_len.begin(), tuple_len.end());
     payload.insert(payload.end(), component_len.begin(), component_len.end());
-    payload.insert(payload.end(), {'m', 'e', 'd', 'i', 'a'});
+    payload.insert(payload.end(), track_namespace.begin(), track_namespace.end());
     const std::vector<std::uint8_t> parameter_count = encode_varint(0);
     payload.insert(payload.end(), parameter_count.begin(), parameter_count.end());
 
@@ -158,13 +158,15 @@ std::vector<std::uint8_t> encode_subscribe_namespace_message(std::uint64_t reque
     return message;
 }
 
-std::vector<std::uint8_t> encode_subscribe_message(std::uint64_t request_id, std::string_view track_name) {
+std::vector<std::uint8_t> encode_subscribe_message(std::uint64_t request_id,
+                                                   std::string_view track_namespace,
+                                                   std::string_view track_name) {
     std::vector<std::uint8_t> payload = encode_varint(request_id);
     const std::vector<std::uint8_t> tuple_len = encode_varint(1);
-    const std::vector<std::uint8_t> component_len = encode_varint(5);
+    const std::vector<std::uint8_t> component_len = encode_varint(track_namespace.size());
     payload.insert(payload.end(), tuple_len.begin(), tuple_len.end());
     payload.insert(payload.end(), component_len.begin(), component_len.end());
-    payload.insert(payload.end(), {'m', 'e', 'd', 'i', 'a'});
+    payload.insert(payload.end(), track_namespace.begin(), track_namespace.end());
     const std::vector<std::uint8_t> track_name_length = encode_varint(track_name.size());
     payload.insert(payload.end(), track_name_length.begin(), track_name_length.end());
     payload.insert(payload.end(), track_name.begin(), track_name.end());
@@ -201,11 +203,13 @@ std::vector<std::uint8_t> encode_publish_ok_message(std::uint64_t request_id) {
     return message;
 }
 
-void queue_subscribe_requests(MockTransport& transport, std::initializer_list<std::pair<std::uint64_t, std::string>> requests) {
+void queue_subscribe_requests(MockTransport& transport,
+                              std::string_view track_namespace,
+                              std::initializer_list<std::pair<std::uint64_t, std::string>> requests) {
     transport.reads[0].push_back(encode_publish_namespace_ok_message(0));
-    transport.reads[0].push_back(encode_subscribe_namespace_message(1));
+    transport.reads[0].push_back(encode_subscribe_namespace_message(1, track_namespace));
     for (const auto& [request_id, track_name] : requests) {
-        transport.reads[0].push_back(encode_subscribe_message(request_id, track_name));
+        transport.reads[0].push_back(encode_subscribe_message(request_id, track_namespace, track_name));
     }
 }
 
@@ -350,14 +354,15 @@ PublishPlan make_span_backed_plan(DraftVersion draft) {
 
 int main() {
     bool ok = true;
+    constexpr std::string_view kTestTrackNamespace = "interop";
 
     MockTransport transport;
     transport.reads[0].push_back(encode_server_setup_message({
         .draft = DraftVersion::kDraft14,
         .max_request_id = 8,
     }));
-    queue_subscribe_requests(transport, {{2, "catalog"}, {4, "vide_1"}});
-    MoqtSession session(transport);
+    queue_subscribe_requests(transport, kTestTrackNamespace, {{2, "catalog"}, {4, "vide_1"}});
+    MoqtSession session(transport, std::string(kTestTrackNamespace));
 
     const EndpointConfig endpoint{
         .host = "example.com",
@@ -392,6 +397,9 @@ int main() {
     ok &= expect(path == "/", "expected draft-14 CLIENT_SETUP path");
     ok &= expect(max_request_id == 0, "expected draft-14 CLIENT_SETUP max_request_id");
     ok &= expect(message_type(transport.writes[1].bytes) == 0x06, "expected PUBLISH_NAMESPACE");
+    ok &= expect(transport.writes[1].bytes == std::vector<std::uint8_t>({0x06, 0x00, 0x0b, 0x00, 0x01, 0x07, 0x69, 0x6e,
+                                                                         0x74, 0x65, 0x72, 0x6f, 0x70, 0x00}),
+                 "expected namespace write to use the configured track namespace");
     ok &= expect(message_type(transport.writes[2].bytes) == 0x12, "expected SUBSCRIBE_NAMESPACE_OK");
     ok &= expect(message_type(transport.writes[3].bytes) == 0x04, "expected first SUBSCRIBE_OK");
     ok &= expect(transport.writes[4].stream_id == 2, "expected first object stream to be unidirectional stream 2");
@@ -406,12 +414,12 @@ int main() {
     ok &= expect(transport.writes[7].fin, "expected second object stream write to set FIN");
     ok &= expect(message_type(transport.writes[8].bytes) == 0x0b, "expected second PUBLISH_DONE");
     ok &= expect(message_type(transport.writes[9].bytes) == 0x09, "expected PUBLISH_NAMESPACE_DONE");
-    ok &= expect(transport.writes[9].bytes == std::vector<std::uint8_t>({0x09, 0x00, 0x07, 0x01, 0x05, 0x6d, 0x65,
-                                                                         0x64, 0x69, 0x61}),
-                 "expected draft-14 PUBLISH_NAMESPACE_DONE to contain only the track namespace");
+    ok &= expect(transport.writes[9].bytes == std::vector<std::uint8_t>({0x09, 0x00, 0x09, 0x01, 0x07, 0x69, 0x6e,
+                                                                         0x74, 0x65, 0x72, 0x6f, 0x70}),
+                 "expected draft-14 PUBLISH_NAMESPACE_DONE to contain the configured track namespace");
 
     MockTransport failing_transport;
-    MoqtSession failing_session(failing_transport);
+    MoqtSession failing_session(failing_transport, std::string(kTestTrackNamespace));
     status = failing_session.connect(endpoint, tls);
     ok &= expect(status.ok, "expected second session connect to succeed");
 
@@ -423,8 +431,8 @@ int main() {
         .draft = DraftVersion::kDraft16,
         .max_request_id = 8,
     }));
-    queue_subscribe_requests(draft16_transport, {{2, "catalog"}, {4, "vide_1"}});
-    MoqtSession draft16_session(draft16_transport);
+    queue_subscribe_requests(draft16_transport, kTestTrackNamespace, {{2, "catalog"}, {4, "vide_1"}});
+    MoqtSession draft16_session(draft16_transport, std::string(kTestTrackNamespace));
     status = draft16_session.connect(endpoint, tls);
     ok &= expect(status.ok, "expected draft-16 session connect to succeed");
 
@@ -445,6 +453,10 @@ int main() {
     ok &= expect(path == "/", "expected draft-16 CLIENT_SETUP path");
     ok &= expect(max_request_id == 0, "expected draft-16 CLIENT_SETUP max_request_id");
     ok &= expect(message_type(draft16_transport.writes[1].bytes) == 0x06, "expected draft-16 PUBLISH_NAMESPACE");
+    ok &= expect(draft16_transport.writes[1].bytes == std::vector<std::uint8_t>({0x06, 0x00, 0x0b, 0x00, 0x01, 0x07,
+                                                                                  0x69, 0x6e, 0x74, 0x65, 0x72, 0x6f,
+                                                                                  0x70, 0x00}),
+                 "expected draft-16 namespace write to use the configured track namespace");
     ok &= expect(message_type(draft16_transport.writes[2].bytes) == 0x12, "expected draft-16 SUBSCRIBE_NAMESPACE_OK");
     ok &= expect(message_type(draft16_transport.writes[3].bytes) == 0x04, "expected first draft-16 SUBSCRIBE_OK");
     ok &= expect(draft16_transport.writes[4].stream_id == 2, "expected first draft-16 object stream");
@@ -466,8 +478,8 @@ int main() {
         std::vector<std::uint8_t>(split_server_setup.begin(), split_server_setup.begin() + 3));
     segmented_transport.reads[0].push_back(
         std::vector<std::uint8_t>(split_server_setup.begin() + 3, split_server_setup.end()));
-    queue_subscribe_requests(segmented_transport, {{2, "catalog"}, {4, "vide_1"}});
-    MoqtSession segmented_session(segmented_transport);
+    queue_subscribe_requests(segmented_transport, kTestTrackNamespace, {{2, "catalog"}, {4, "vide_1"}});
+    MoqtSession segmented_session(segmented_transport, std::string(kTestTrackNamespace));
     status = segmented_session.connect(endpoint, tls);
     ok &= expect(status.ok, "expected segmented setup connect to succeed");
     status = segmented_session.publish(materialize_publish_plan(make_span_backed_plan(DraftVersion::kDraft14), source_bytes));