use hang::catalog::{Catalog, Container, PRIORITY, VideoCodec, VideoConfig};
use hang::moq_net;
use crate::clock::StreamClock;
use crate::codec::{EncodedFrame, Encoder, EncoderSettings};
use crate::data::{DataPublisher, DataSettings};
use crate::{ClientConfig, Error, Image, Result};
pub const VIDEO_TRACK: &str = "video";
#[derive(Clone)]
pub struct Publisher {
origin: moq_net::origin::Producer,
connection: moq_tokio::Connection,
}
impl Publisher {
pub fn connect(config: &ClientConfig) -> Result<Self> {
let origin = moq_tokio::origin::spawn();
let connection = config.client()?.with_publisher(&origin).connect(config.url.clone());
Ok(Self { origin, connection })
}
pub(crate) fn from_parts(origin: moq_net::origin::Producer, connection: moq_tokio::Connection) -> Self {
Self { origin, connection }
}
pub async fn established(&self) -> Result<()> {
crate::client::established(&self.connection).await
}
pub async fn closed(&self) -> Result<()> {
Ok(self.connection.closed().await?)
}
pub async fn close(&self) -> Result<()> {
Ok(self.connection.clone().close().await?)
}
pub fn create_image_broadcast(&self, name: &str, settings: EncoderSettings) -> Result<ImagePublisher> {
ImagePublisher::new(&self.origin, name, settings)
}
pub fn create_data_broadcast(&self, name: &str, settings: DataSettings) -> Result<DataPublisher> {
DataPublisher::new(&self.origin, name, settings)
}
}
pub struct ImagePublisher {
name: String,
broadcast: moq_net::broadcast::Producer,
catalog: moq_net::track::Producer,
video: moq_net::track::Producer,
group: Option<moq_net::group::Producer>,
budget: GroupBudget,
encoder: Encoder,
rendition: Option<(u32, u32, VideoCodec)>,
clock: StreamClock,
}
impl ImagePublisher {
fn new(origin: &moq_net::origin::Producer, name: &str, settings: EncoderSettings) -> Result<Self> {
let encoder = Encoder::new(settings)?;
let broadcast = origin.create_broadcast(name)?;
broadcast.announce(Default::default())?;
let catalog = broadcast.create_track(Catalog::DEFAULT_NAME, Catalog::default_track_info())?;
let video = broadcast.create_track(VIDEO_TRACK, hang::container::track_info(PRIORITY.video))?;
tracing::info!(broadcast = name, codec = %encoder.settings().codec, "announced image broadcast");
Ok(Self {
name: name.to_string(),
broadcast,
catalog,
video,
group: None,
budget: GroupBudget::default(),
encoder,
rendition: None,
clock: StreamClock::default(),
})
}
pub fn name(&self) -> &str {
&self.name
}
pub fn publish(&mut self, image: &Image) -> Result<bool> {
match self.encoder.encode(image)? {
Some(frame) => {
self.publish_encoded(&frame)?;
Ok(true)
}
None => Ok(false),
}
}
pub fn publish_encoded(&mut self, frame: &EncodedFrame) -> Result<()> {
if frame.keyframe {
self.update_catalog(frame)?;
if let Some(group) = self.group.take() {
group.finish()?;
}
self.group = Some(self.video.append_group()?);
self.budget = GroupBudget::default();
} else if self.group.is_some() && !self.budget.fits(frame.data.len()) {
tracing::warn!(
broadcast = %self.name,
"video group is full; raise the bitrate budget or shorten the keyframe interval"
);
if let Some(group) = self.group.take() {
group.finish()?;
}
}
let Some(group) = self.group.as_mut() else {
self.encoder.force_keyframe();
return Ok(());
};
let timestamp = self.clock.micros(frame.timestamp);
let frame = hang::container::Frame {
timestamp: moq_net::Timestamp::from_micros(timestamp).map_err(|_| Error::Timestamp)?,
payload: frame.data.clone(),
};
frame.write_to(group)?;
self.budget.add(frame.payload.len());
if self.budget.nearly_full() {
self.encoder.force_keyframe();
}
Ok(())
}
fn update_catalog(&mut self, frame: &EncodedFrame) -> Result<()> {
let codec = frame.codec.clone();
let rendition = (frame.width, frame.height, codec.clone());
if self.rendition.as_ref() == Some(&rendition) {
return Ok(());
}
let settings = self.encoder.settings();
let mut config = VideoConfig::new(codec.clone());
config.coded_width = Some(frame.width);
config.coded_height = Some(frame.height);
config.bitrate = Some(settings.bitrate as u64);
config.framerate = Some(settings.max_fps as f64);
config.container = Container::Legacy;
let mut catalog = Catalog::<()>::default();
catalog.video.insert(VIDEO_TRACK, config)?;
let mut group = self.catalog.append_group()?;
group.write_frame(moq_net::Timestamp::now(), catalog.to_json()?)?;
group.finish()?;
tracing::info!(
broadcast = %self.name,
codec = %codec,
width = frame.width,
height = frame.height,
"published catalog"
);
self.rendition = Some(rendition);
Ok(())
}
}
#[derive(Debug, Default)]
pub(crate) struct GroupBudget {
frames: usize,
bytes: u64,
}
impl GroupBudget {
const OVERHEAD: u64 = 8;
pub(crate) fn fits(&self, payload: usize) -> bool {
self.frames < moq_net::group::MAX_GROUP_FRAMES
&& self.bytes + payload as u64 + Self::OVERHEAD <= moq_net::group::MAX_CACHE_BYTES
}
pub(crate) fn add(&mut self, payload: usize) {
self.frames += 1;
self.bytes += payload as u64 + Self::OVERHEAD;
}
fn nearly_full(&self) -> bool {
self.frames >= moq_net::group::MAX_GROUP_FRAMES / 4 * 3 || self.bytes >= moq_net::group::MAX_CACHE_BYTES / 4 * 3
}
}
impl Drop for ImagePublisher {
fn drop(&mut self) {
if let Some(group) = self.group.take() {
let _ = group.finish();
}
self.broadcast.close();
}
}
#[cfg(test)]
mod tests {
use std::time::Duration;
use bytes::Bytes;
use super::*;
use crate::codec::Codec;
fn publisher(settings: EncoderSettings) -> ImagePublisher {
ImagePublisher::new(&moq_tokio::origin::spawn(), "camera", settings).unwrap()
}
#[tokio::test]
async fn long_keyframe_interval_starts_groups_early() {
if Codec::available().is_empty() {
return;
}
let mut publisher = publisher(EncoderSettings {
keyframe_interval: Duration::from_secs(3600),
..Default::default()
});
let mut keyframes = 0;
for t in 0..moq_net::group::MAX_GROUP_FRAMES as u32 + 100 {
publisher
.publish(&crate::codec::tests::test_pattern(16, 16, t))
.unwrap();
keyframes += usize::from(publisher.budget.frames == 1);
}
assert_eq!(keyframes, 2);
}
#[tokio::test]
async fn full_group_waits_for_a_keyframe() {
if Codec::available().is_empty() {
return;
}
let mut publisher = publisher(EncoderSettings::default());
let frame = |n: u64, keyframe: bool| EncodedFrame {
data: Bytes::from_static(&[0; 16]),
keyframe,
width: 16,
height: 16,
timestamp: Duration::from_millis(n * 33),
codec: VideoCodec::VP8,
};
let limit = moq_net::group::MAX_GROUP_FRAMES as u64;
for n in 0..limit + 10 {
publisher.publish_encoded(&frame(n, n == 0)).unwrap();
}
assert!(publisher.group.is_none());
publisher.publish_encoded(&frame(limit + 10, true)).unwrap();
assert_eq!(publisher.budget.frames, 1);
}
}