use std::time::Duration;
use bytes::Bytes;
use hang::catalog::Catalog;
use hang::moq_net;
use crate::codec::{Codec, Decoder};
use crate::data::{DataMode, DataSettings, DataSubscriber};
use crate::{ClientConfig, Error, Image, Result};
#[derive(Clone)]
pub struct Subscriber {
origin: moq_net::origin::Producer,
connection: moq_tokio::Connection,
}
impl Subscriber {
pub fn connect(config: &ClientConfig) -> Result<Self> {
let origin = moq_tokio::origin::spawn();
let connection = config
.client()?
.with_subscriber(origin.clone())
.connect(config.url.clone());
Ok(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 async fn subscribe_images(&self, name: &str) -> Result<ImageSubscriber> {
let (broadcast, catalog) = self.catalog(name).await?;
images(name, broadcast, &catalog).await
}
pub async fn subscribe_data(&self, name: &str) -> Result<DataSubscriber> {
let (broadcast, catalog) = self.catalog(name).await?;
data(name, broadcast, &catalog).await
}
pub async fn subscribe(&self, name: &str) -> Result<Subscription> {
let (broadcast, catalog) = self.catalog(name).await?;
match Kind::of(&catalog) {
Kind::Images => Ok(Subscription::Images(images(name, broadcast, &catalog).await?)),
Kind::Data => Ok(Subscription::Data(data(name, broadcast, &catalog).await?)),
Kind::None => Err(Error::NoTracks(name.to_string())),
}
}
async fn catalog(&self, name: &str) -> Result<(moq_net::broadcast::Consumer, Catalog)> {
let consumer = self.origin.consume();
let mut announced = consumer.announced();
loop {
let update = announced
.next()
.await
.ok_or_else(|| Error::NotAnnounced(name.to_string()))?;
if update.kind.is_active() && update.prefix.as_str() == name {
break;
}
}
let broadcast = consumer.request_broadcast(name).await?;
let mut catalog = Catalog::<()>::subscribe(&broadcast).await?;
let catalog = catalog.next().await?.ok_or_else(|| Error::NoTracks(name.to_string()))?;
Ok((broadcast, catalog))
}
}
async fn images(name: &str, broadcast: moq_net::broadcast::Consumer, catalog: &Catalog) -> Result<ImageSubscriber> {
let mut renditions = catalog.video.ranked().peekable();
if renditions.peek().is_none() {
return Err(Error::NoVideo(name.to_string()));
}
let mut offered = Vec::new();
let (track, config, codec) = renditions
.find_map(|(track, config)| {
offered.push(config.codec.to_string());
let codec = Codec::from_catalog(&config.codec).filter(|c| c.is_available())?;
Some((track, config, codec))
})
.ok_or_else(|| Error::UnsupportedCodec(offered.join(", ")))?;
tracing::info!(
broadcast = name,
track = %track,
codec = %config.codec,
width = ?config.coded_width,
height = ?config.coded_height,
"subscribing"
);
let video = GroupReader::subscribe(&broadcast, track, true).await?;
Ok(ImageSubscriber {
_broadcast: broadcast,
video,
codec,
decoder: Decoder::new(codec)?,
})
}
async fn data(name: &str, broadcast: moq_net::broadcast::Consumer, catalog: &Catalog) -> Result<DataSubscriber> {
let (track, settings) = DataSettings::from_catalog(catalog).ok_or_else(|| Error::NoData(name.to_string()))?;
tracing::info!(
broadcast = name,
track,
format = %settings.format,
mode = %settings.mode,
ros_type = settings.ros_type.as_deref().unwrap_or_default(),
"subscribing"
);
let reader = GroupReader::subscribe(&broadcast, &track, settings.mode == DataMode::Snapshot).await?;
Ok(DataSubscriber::new(broadcast, reader, settings))
}
#[derive(Debug, PartialEq, Eq)]
enum Kind {
Images,
Data,
None,
}
impl Kind {
fn of(catalog: &Catalog) -> Self {
let decodable = catalog
.video
.ranked()
.any(|(_, config)| Codec::from_catalog(&config.codec).is_some_and(Codec::is_available));
if decodable {
Self::Images
} else if DataSettings::from_catalog(catalog).is_some() {
Self::Data
} else if !catalog.video.renditions.is_empty() {
Self::Images
} else {
Self::None
}
}
}
pub enum Subscription {
Images(ImageSubscriber),
Data(DataSubscriber),
}
pub(crate) struct GroupReader {
track: moq_net::track::Ordered,
group: Option<moq_net::group::Consumer>,
skip: bool,
}
impl GroupReader {
async fn subscribe(broadcast: &moq_net::broadcast::Consumer, track: &str, skip: bool) -> Result<Self> {
let track = broadcast
.track(track)?
.subscribe(moq_net::track::Subscription::default())
.await?
.ordered();
Ok(Self {
track,
group: None,
skip,
})
}
pub(crate) async fn next_frame(&mut self) -> Result<Option<moq_net::frame::Frame>> {
loop {
let Some(group) = self.group.as_mut() else {
match self.track.next_group().await? {
Some(group) => self.group = Some(group),
None => return Ok(None),
}
continue;
};
let frame = if self.skip {
tokio::select! {
biased;
next = self.track.next_group() => {
match next? {
Some(group) => self.group = Some(group),
None => return Ok(None),
}
continue;
}
frame = group.read_frame() => frame,
}
} else {
group.read_frame().await
};
match frame {
Ok(Some(frame)) => return Ok(Some(frame)),
Ok(None) => self.group = None,
Err(err) => {
tracing::debug!(%err, "group ended early, waiting for the next one");
self.group = None;
}
}
}
}
}
#[derive(Debug, Clone)]
pub struct VideoFrame {
pub timestamp: Duration,
pub keyframe: bool,
pub data: Bytes,
}
pub struct ImageSubscriber {
_broadcast: moq_net::broadcast::Consumer,
video: GroupReader,
codec: Codec,
decoder: Decoder,
}
impl ImageSubscriber {
pub fn codec(&self) -> Codec {
self.codec
}
pub async fn next_frame(&mut self) -> Result<Option<VideoFrame>> {
let Some(frame) = self.video.next_frame().await? else {
return Ok(None);
};
let frame = hang::container::Frame::decode(frame.payload)?;
Ok(Some(VideoFrame {
timestamp: Duration::from_micros(frame.timestamp.as_micros() as u64),
keyframe: self.codec.is_keyframe(&frame.payload),
data: frame.payload,
}))
}
pub async fn next_image(&mut self) -> Result<Option<Image>> {
while let Some(frame) = self.next_frame().await? {
if let Some(image) = self.decoder.decode(&frame.data, frame.timestamp)? {
return Ok(Some(image));
}
}
Ok(None)
}
}
#[cfg(test)]
mod tests {
use super::*;
fn catalog(json: serde_json::Value) -> Catalog {
serde_json::from_value(json).unwrap()
}
#[test]
fn picks_what_this_build_can_read() {
let video = |codec: &str| serde_json::json!({ "renditions": { "video": { "codec": codec } } });
let data = serde_json::json!({ "tracks": { "data": { "mode": "snapshot" } } });
assert_eq!(Kind::of(&catalog(serde_json::json!({}))), Kind::None);
assert_eq!(Kind::of(&catalog(serde_json::json!({ "json": data }))), Kind::Data);
assert_eq!(
Kind::of(&catalog(serde_json::json!({ "video": video("av01.0.04M.08") }))),
Kind::Images
);
assert_eq!(
Kind::of(&catalog(
serde_json::json!({ "video": video("av01.0.04M.08"), "json": data })
)),
Kind::Data
);
for codec in Codec::available() {
let codec = match codec {
Codec::Vp8 => "vp8",
Codec::H264 => "avc3.42001f",
};
assert_eq!(
Kind::of(&catalog(serde_json::json!({ "video": video(codec), "json": data }))),
Kind::Images,
"{codec}"
);
}
}
}