use hang::catalog::{PRIORITY, VideoCodec};
use hang::moq_net;
use crate::catalog::{self, VIDEO_TRACK};
use crate::clock::StreamClock;
use crate::codec::{EncodedFrame, Encoder, EncoderSettings};
use crate::data::{DataPublisher, DataSettings};
use crate::track::{BroadcastWriter, GroupWriter};
use crate::{ClientConfig, Error, Image, Result, Session};
#[derive(Clone)]
pub struct Publisher {
origin: moq_net::origin::Producer,
session: Session,
}
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,
session: Session::new(connection),
})
}
pub(crate) fn from_parts(origin: moq_net::origin::Producer, session: Session) -> Self {
Self { origin, session }
}
pub fn session(&self) -> &Session {
&self.session
}
pub async fn established(&self) -> Result<()> {
self.session.established().await
}
pub async fn closed(&self) -> Result<()> {
self.session.closed().await
}
pub async fn close(&self) -> Result<()> {
self.session.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 {
video: GroupWriter,
broadcast: BroadcastWriter,
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 = BroadcastWriter::create(origin, name)?;
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 {
video: GroupWriter::new(video),
broadcast,
encoder,
rendition: None,
clock: StreamClock::default(),
})
}
pub fn name(&self) -> &str {
self.broadcast.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)?;
self.video.start_group()?;
} else if self.video.is_open() && !self.video.fits(frame.data.len()) {
tracing::warn!(
broadcast = %self.name(),
"video group is full; raise the bitrate budget or shorten the keyframe interval"
);
self.video.finish_group()?;
}
if !self.video.is_open() {
self.encoder.force_keyframe();
return Ok(());
}
let timestamp = self.clock.micros(frame.timestamp);
self.video.write_container(&hang::container::Frame {
timestamp: moq_net::Timestamp::from_micros(timestamp).map_err(|_| Error::Timestamp)?,
payload: frame.data.clone(),
})?;
if self.video.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 catalog = catalog::video(frame, self.encoder.settings())?;
self.broadcast.publish_catalog(&catalog)?;
tracing::info!(
broadcast = %self.name(),
codec = %codec,
width = frame.width,
height = frame.height,
"published catalog"
);
self.rendition = Some(rendition);
Ok(())
}
}
#[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.video.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.video.is_open());
publisher.publish_encoded(&frame(limit + 10, true)).unwrap();
assert_eq!(publisher.video.frames(), 1);
}
}