use std::time::Duration;
use anyhow::Context;
use clap::Parser;
use moqros::ros::spawn_ros_to_moq;
use moqros_cli::{QosArgs, RelayArgs, init_logging, spawn_spinner};
#[derive(Debug, Parser)]
#[command(version, about)]
struct Cli {
#[arg(long, default_value = "/image_raw")]
topic: String,
#[arg(long)]
broadcast: Option<String>,
#[arg(long, default_value_t = moqros::Codec::default())]
codec: moqros::Codec,
#[arg(long, default_value_t = 2_000_000)]
bitrate: u32,
#[arg(long, default_value_t = 30.0)]
fps: f32,
#[arg(long, default_value_t = 2000)]
keyframe_interval_ms: u64,
#[command(flatten)]
relay: RelayArgs,
#[command(flatten)]
qos: QosArgs,
}
#[tokio::main]
async fn main() -> anyhow::Result<()> {
init_logging();
let (cli, mut node) = moqros_cli::init::<Cli>("moqros_pub")?;
let broadcast = cli
.broadcast
.clone()
.unwrap_or_else(|| moqros::broadcast_name_for_topic(&cli.topic));
let publisher = moqros::Publisher::connect(&cli.relay.config())?;
let settings = moqros::EncoderSettings {
codec: cli.codec,
bitrate: cli.bitrate,
max_fps: cli.fps,
keyframe_interval: Duration::from_millis(cli.keyframe_interval_ms),
..Default::default()
};
let images = publisher.create_image_broadcast(&broadcast, settings)?;
let bridge = spawn_ros_to_moq(&mut node, &cli.topic, cli.qos.profile(), images)?;
let mut spinner = spawn_spinner(node);
tracing::info!(topic = cli.topic, broadcast, url = %cli.relay.url, "bridging ROS -> MoQ");
tokio::select! {
res = bridge => {
let stats = res??;
tracing::info!(?stats, "topic stream ended");
}
res = publisher.closed() => res.context("relay connection closed")?,
err = spinner.failed() => return Err(err),
_ = tokio::signal::ctrl_c() => tracing::info!("interrupted"),
}
Ok(())
}