Align catalog metadata and add forward publish mode

Author: mondain

README.md

@@ -15,7 +15,7 @@ It is buildable and testable today, but it is not yet a full interoperable MOQT
 
 - Parses fragmented MP4 input with `ftyp` + `moov` + `moof`/`mdat`
 - Remuxes non-fragmented MP4 input into synthesized fragmented media objects
-- Extracts basic track metadata and codec identifiers from MP4 sample tables
+- Extracts track metadata and RFC 6381 codec identifiers from MP4 sample tables
 - Builds a publish plan consisting of initialization and media objects
 - Emits planned objects to disk for inspection
 - Keeps fragmented input on a zero-copy fast path where possible
@@ -161,9 +161,20 @@ Use `--emit-dir` to inspect the emitted catalog and media objects on disk:
 The output directory should currently contain:
 
 - `catalog.json`
-- one `.mp4` object file per media object
+- one `*_init.mp4` file per media track
+- one `*_media.mp4` file per emitted media object
+- one `*_probe.mp4` file per emitted media object for direct `ffprobe` use
 - `publish-plan.txt`
 
+The current catalog format includes:
+
+- `role` with values such as `video` and `audio`
+- RFC 6381 `codec` strings such as `avc1.64000C` and `mp4a.40.2`
+- `renderGroup` and `isLive`
+- `width` and `height` for video tracks
+- `sampleRate` and `channelCount` for audio tracks
+- base64-encoded codec `initData` per track
+
 ### Relay interoperability test
 
 To attempt a live publish against a relay:
@@ -173,6 +184,7 @@ OPENMOQ_PICOQUIC_TRACE=1 ./build/openmoq-publisher \
   --input sample.mp4 \
   --endpoint moqt://interop-relay.cloudflare.mediaoverquic.com:443/moq \
   --namespace interop \
+  --forward 0 \
   --insecure
 ```
 
@@ -181,7 +193,7 @@ Current status as of March 12, 2026:
 - 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`
+- with `--forward 0`, 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
 
 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.
@@ -229,6 +241,7 @@ Transport-oriented CLI flags are also present now:
   --input sample.mp4 \
   --endpoint localhost:4433 \
   --namespace media \
+  --forward 0 \
   --alpn moq-00 \
   --insecure
 ```
@@ -240,6 +253,7 @@ Current status:
 - `--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
 - `--namespace` lets you choose the advertised track namespace during transport tests
+- `--forward 0|1` selects whether the publisher waits for `SUBSCRIBE` (`0`) or immediately sends `PUBLISH` requests and forwards objects after namespace announce (`1`)
 - 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
 

include/openmoq/publisher/cli_options.h

@@ -16,6 +16,7 @@ struct CliOptions {
     transport::TlsConfig tls;
     DraftVersion draft_version = DraftVersion::kDraft14;
     std::string track_namespace = "media";
+    bool forward = false;
     bool dump_plan = false;
 };
 

include/openmoq/publisher/mp4_box.h

@@ -25,7 +25,14 @@ struct TrackDescription {
     std::uint32_t track_id = 0;
     std::string handler_type;
     std::string codec;
+    std::string sample_entry_type;
     std::string track_name;
+    std::uint32_t timescale = 0;
+    std::uint32_t width = 0;
+    std::uint32_t height = 0;
+    std::uint32_t channel_count = 0;
+    std::uint32_t sample_rate = 0;
+    double frame_rate = 0.0;
 };
 
 struct ParsedMp4 {

include/openmoq/publisher/transport/moqt_session.h

@@ -13,7 +13,9 @@ namespace openmoq::publisher::transport {
 
 class MoqtSession {
 public:
-    explicit MoqtSession(PublisherTransport& transport, std::string track_namespace = "media");
+    explicit MoqtSession(PublisherTransport& transport,
+                         std::string track_namespace = "media",
+                         bool auto_forward = false);
 
     TransportStatus connect(const EndpointConfig& endpoint, const TlsConfig& tls);
     TransportStatus publish(const openmoq::publisher::PublishPlan& plan);
@@ -26,6 +28,7 @@ class MoqtSession {
 
     PublisherTransport& transport_;
     std::string track_namespace_;
+    bool auto_forward_ = false;
     std::optional<EndpointConfig> endpoint_;
     std::uint64_t control_stream_id_ = 0;
     std::uint64_t peer_max_request_id_ = 0;

src/cli_options.cpp

@@ -49,6 +49,16 @@ transport::EndpointConfig parse_endpoint(std::string_view value) {
     return endpoint;
 }
 
+bool parse_forward_flag(std::string_view value) {
+    if (value == "0") {
+        return false;
+    }
+    if (value == "1") {
+        return true;
+    }
+    throw std::runtime_error("unsupported --forward value: expected 0 or 1");
+}
+
 }  // namespace
 
 CliOptions parse_cli_options(int argc, char** argv) {
@@ -86,6 +96,8 @@ CliOptions parse_cli_options(int argc, char** argv) {
             options.draft_version = parse_draft(require_value("--draft"));
         } else if (argument == "--namespace") {
             options.track_namespace = std::string(require_value("--namespace"));
+        } else if (argument == "--forward") {
+            options.forward = parse_forward_flag(require_value("--forward"));
         } else if (argument == "--emit-dir") {
             options.emit_dir = std::filesystem::path(require_value("--emit-dir"));
         } else if (argument == "--dump-plan") {
@@ -113,7 +125,7 @@ CliOptions parse_cli_options(int argc, char** argv) {
 
 std::string build_usage(const char* argv0) {
     return std::string("Usage: ") + argv0 +
-           " --input <mp4> [--draft 14|16] [--namespace <value>] [--dump-plan] [--emit-dir <dir>]"
+           " --input <mp4> [--draft 14|16] [--namespace <value>] [--forward 0|1] [--dump-plan] [--emit-dir <dir>]"
            " [--endpoint host:port|moqt://host:port/path] [--alpn value]"
            " [--cert file] [--key file] [--ca file] [--insecure]";
 }

src/cmsf_packager.cpp

@@ -5,6 +5,7 @@
 #include <fstream>
 #include <iomanip>
 #include <algorithm>
+#include <cmath>
 #include <map>
 #include <sstream>
 #include <stdexcept>
@@ -122,7 +123,7 @@ std::string base64_encode(std::span<const std::uint8_t> bytes) {
     return encoded;
 }
 
-std::string track_kind(std::string_view handler_type) {
+std::string track_role(std::string_view handler_type) {
     if (handler_type == "vide") {
         return "video";
     }
@@ -132,6 +133,17 @@ std::string track_kind(std::string_view handler_type) {
     return "data";
 }
 
+std::string json_number(double value) {
+    std::ostringstream out;
+    const double rounded = std::round(value);
+    if (std::fabs(value - rounded) < 0.0005) {
+        out << static_cast<long long>(rounded);
+    } else {
+        out << std::fixed << std::setprecision(3) << value;
+    }
+    return out.str();
+}
+
 std::uint32_t track_id_from_trak(const Mp4Box& trak, std::span<const std::uint8_t> bytes) {
     const Mp4Box* tkhd = find_child_box(trak, "tkhd");
     if (tkhd == nullptr || tkhd->payload.size < 20) {
@@ -305,6 +317,7 @@ PublishPlan build_publish_plan(const SegmentedMp4& segmented_mp4, DraftVersion v
                                     .track_id = 0,
                                     .handler_type = "meta",
                                     .codec = "catalog",
+                                    .sample_entry_type = "catalog",
                                     .track_name = "catalog",
                                 });
 
@@ -343,11 +356,24 @@ PublishPlan build_publish_plan(const SegmentedMp4& segmented_mp4, DraftVersion v
         catalog << '{'
                 << "\"name\":\"" << json_escape(track.track_name) << "\","
                 << "\"id\":" << track.track_id << ','
-                << "\"kind\":\"" << track_kind(track.handler_type) << "\","
-                << "\"handler\":\"" << json_escape(track.handler_type) << "\","
+                << "\"role\":\"" << track_role(track.handler_type) << "\","
                 << "\"codec\":\"" << json_escape(track.codec) << "\","
                 << "\"packaging\":\"cmaf\","
-                << "\"initData\":\"" << init_data_by_track.at(track.track_name) << "\""
+                << "\"renderGroup\":1,"
+                << "\"isLive\":false,";
+        if (track.handler_type == "vide") {
+            catalog << "\"width\":" << track.width << ','
+                    << "\"height\":" << track.height;
+            if (track.frame_rate > 0.0) {
+                catalog << ','
+                        << "\"frameRate\":" << json_number(track.frame_rate);
+            }
+            catalog << ',';
+        } else if (track.handler_type == "soun") {
+            catalog << "\"sampleRate\":" << track.sample_rate << ','
+                    << "\"channelCount\":" << track.channel_count << ',';
+        }
+        catalog << "\"initData\":\"" << init_data_by_track.at(track.track_name) << "\""
                 << '}';
     }
     catalog << "]}";

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, options.track_namespace);
+            MoqtSession session(transport, options.track_namespace, options.forward);
 
             TransportStatus status = session.connect(*options.endpoint, options.tls);
             if (!status.ok) {