Fix: Added support for `url` property. TODO: add buffer

gst-warp-sink/Cargo.lock

@@ -1024,6 +1024,12 @@ dependencies = [
  "log",
 ]
 
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
 [[package]]
 name = "libc"
 version = "0.2.150"
@@ -1085,6 +1091,8 @@ dependencies = [
  "rustls",
  "rustls-native-certs",
  "rustls-pemfile",
+ "tracing",
+ "tracing-subscriber",
  "url",
  "webtransport-quinn",
 ]
@@ -1167,6 +1175,16 @@ dependencies = [
  "minimal-lexical",
 ]
 
+[[package]]
+name = "nu-ansi-term"
+version = "0.46.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84"
+dependencies = [
+ "overload",
+ "winapi",
+]
+
 [[package]]
 name = "num-bigint"
 version = "0.4.4"
@@ -1240,6 +1258,12 @@ dependencies = [
  "paste",
 ]
 
+[[package]]
+name = "overload"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
+
 [[package]]
 name = "parking"
 version = "2.2.0"
@@ -1657,6 +1681,15 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "sharded-slab"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
+dependencies = [
+ "lazy_static",
+]
+
 [[package]]
 name = "slab"
 version = "0.4.9"
@@ -1764,6 +1797,16 @@ dependencies = [
  "syn 2.0.39",
 ]
 
+[[package]]
+name = "thread_local"
+version = "1.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fdd6f064ccff2d6567adcb3873ca630700f00b5ad3f060c25b5dcfd9a4ce152"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+]
+
 [[package]]
 name = "tinyvec"
 version = "1.6.0"
@@ -1881,6 +1924,32 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54"
 dependencies = [
  "once_cell",
+ "valuable",
+]
+
+[[package]]
+name = "tracing-log"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3"
+dependencies = [
+ "log",
+ "once_cell",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-subscriber"
+version = "0.3.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad0f048c97dbd9faa9b7df56362b8ebcaa52adb06b498c050d2f4e32f90a7a8b"
+dependencies = [
+ "nu-ansi-term",
+ "sharded-slab",
+ "smallvec",
+ "thread_local",
+ "tracing-core",
+ "tracing-log",
 ]
 
 [[package]]
@@ -1927,6 +1996,12 @@ dependencies = [
  "percent-encoding",
 ]
 
+[[package]]
+name = "valuable"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d"
+
 [[package]]
 name = "value-bag"
 version = "1.4.2"

gst-warp-sink/Cargo.toml

@@ -25,6 +25,8 @@ bytes = "1.5.0"
 quinn = "0.10"
 webtransport-quinn = "0.6.1"
 url = "2"
+tracing = "0.1"
+tracing-subscriber = "0.3"
 
 # Crypto
 rustls = { version = "0.21", features = ["dangerous_configuration"] }

gst-warp-sink/src/moqsink/imp.rs

@@ -10,6 +10,7 @@ use moq_transport::VarInt;
 use once_cell::sync::Lazy;
 use std::convert::TryInto;
 use std::sync::Mutex;
+use url::Url;
 
 pub const ELEMENT_NAME: &str = "MoqSink";
 const ELEMENT_CLASS_NAME: &str = "MoqSink";
@@ -114,52 +115,66 @@ impl Default for Settings {
 
 #[derive(Debug)]
 struct StartedState {
-    mp4_parser: Mp4Parser,
-    // Atoms in init sequence that must be repeated at each key frame.
-    ftype_atom: Option<Mp4Atom>,
-    moov_atom: Option<Mp4Atom>,
-    // These atoms that must be buffered and pushed as a single buffer.
-    moof_atom: Option<Mp4Atom>,
-    // Below members that track current fragment (moof, mdat).
-    /// Minimum PTS in fragment.
-    fragment_pts: ClockTime,
-    /// Minimum DTS in fragment.
-    fragment_dts: ClockTime,
-    /// Maximum PTS + duration in fragment.
-    fragment_max_pts_plus_duration: ClockTime,
-    /// Minimum offset in fragment.
-    fragment_offset: Option<u64>,
-    /// Maximum offset_end in fragment.
-    fragment_offset_end: Option<u64>,
-    fragment_buffer_flags: gst::BufferFlags,
-}
-enum State {
-    Started { state: StartedState },
+    // // We hold on to publisher so we don't close then while media is still being published.
+    // broadcast: broadcast::Publisher,
+    // //parses the mp4 boxes
+    // mp4_parser: Mp4Parser,
+    // // Atoms in init sequence that must be repeated at each key frame.
+    // ftype_atom: Option<Mp4Atom>,
+    // moov_atom: Option<Mp4Atom>,
+    // // These atoms that must be buffered and pushed as a single buffer.
+    // moof_atom: Option<Mp4Atom>,
+    // // Below members that track current fragment (moof, mdat).
+    // /// Minimum PTS in fragment.
+    // fragment_pts: ClockTime,
+    // /// Minimum DTS in fragment.
+    // fragment_dts: ClockTime,
+    // /// Maximum PTS + duration in fragment.
+    // fragment_max_pts_plus_duration: ClockTime,
+    // /// Minimum offset in fragment.
+    // fragment_offset: Option<u64>,
+    // /// Maximum offset_end in fragment.
+    // fragment_offset_end: Option<u64>,
+    // fragment_buffer_flags: gst::BufferFlags,
+    // We hold on to publisher so we don't close then while media is still being published.
+    broadcast: broadcast::Publisher,
 }
 
-impl Default for State {
-    fn default() -> State {
-        State::Started {
-            state: StartedState {
-                mp4_parser: Mp4Parser::new(),
-                ftype_atom: None,
-                moov_atom: None,
-                moof_atom: None,
-                fragment_pts: ClockTime::none(),
-                fragment_dts: ClockTime::none(),
-                fragment_max_pts_plus_duration: ClockTime::none(),
-                fragment_offset: None,
-                fragment_offset_end: None,
-                fragment_buffer_flags: gst::BufferFlags::DELTA_UNIT,
-            },
-        }
+impl StartedState {
+
 }
+
+#[derive(Default)]
+enum State {
+    #[default]
+    Stopped,
+    Completed,
+    Started(StartedState)
 }
 
+// impl Default for State {
+//     fn default() -> State {
+//         State::Started {
+//             state: StartedState {
+//                 mp4_parser: Mp4Parser::new(),
+//                 broadcast: None,
+//                 ftype_atom: None,
+//                 moov_atom: None,
+//                 moof_atom: None,
+//                 fragment_pts: ClockTime::none(),
+//                 fragment_dts: ClockTime::none(),
+//                 fragment_max_pts_plus_duration: ClockTime::none(),
+//                 fragment_offset: None,
+//                 fragment_offset_end: None,
+//                 fragment_buffer_flags: gst::BufferFlags::DELTA_UNIT,
+//             },
+//         }
+//     }
+// }
+
 pub struct MoqSink {
     state: Mutex<State>,
-    url: Mutex<Option<RelayUrl>>,
-    srcpad: gst::Pad,
+    url: Mutex<Option<Url>>,
     settings: Mutex<Settings>,
 }
 
@@ -171,7 +186,7 @@ static CAT: Lazy<gst::DebugCategory> = Lazy::new(|| {
     )
 });
 
-impl MoqSink {
+// impl MoqSink {
 // fn sink_chain(
 //     &self,
 //     pad: &gst::Pad,
@@ -365,13 +380,117 @@ impl MoqSink {
 //     //Let this be our publisher
 //     Ok(())
 // }
+// }
+impl MoqSink {
+    fn start(&self) -> Result<(), gst::ErrorMessage> {
+        let mut state = self.state.lock().unwrap();
+        let settings = self.settings.lock().unwrap();
+
+        if let State::Started { .. } = *state {
+            unreachable!("Element already started");
+        }
+
+        let relay_url = {
+            let url = self.url.lock().unwrap();
+            match *url {
+                Some(ref url) => url.clone(),
+                None => {
+                    return Err(gst::error_msg!(
+                        gst::ResourceError::Settings,
+                        ["Cannot start without a URL being set"]
+                    ));
+                }
+            }
+        };
+
+        // Disable tracing so we don't get a bunch of Quinn spam.
+        let tracer = tracing_subscriber::FmtSubscriber::builder()
+            .with_max_level(tracing::Level::WARN)
+            .finish();
+        tracing::subscriber::set_global_default(tracer).unwrap();
+
+        // Create a list of acceptable root certificates.
+        let mut roots = rustls::RootCertStore::empty();
+
+        // Add the platform's native root certificates.
+        for cert in
+            rustls_native_certs::load_native_certs().context("could not load platform certs")?
+        {
+            roots
+                .add(&rustls::Certificate(cert.0))
+                .context("failed to add root cert")?;
+        }
+
+        let mut tls_config = rustls::ClientConfig::builder()
+            .with_safe_defaults()
+            .with_root_certificates(roots)
+            .with_no_client_auth();
+
+        tls_config.alpn_protocols = vec![webtransport_quinn::ALPN.to_vec()]; // this one is important
+
+        let arc_tls_config = std::sync::Arc::new(tls_config);
+        let quinn_client_config = quinn::ClientConfig::new(arc_tls_config);
+
+        let mut endpoint = quinn::Endpoint::client("[::]:0")?;
+        endpoint.set_default_client_config(quinn_client_config);
+
+        gst::debug!(CAT,imp: self,"connecting to relay: url={:?}",relay_url);
+
+        let session = webtransport_quinn::connect(&endpoint, &relay_url)
+            .await
+            .context("failed to create WebTransport session")?;
+
+        let (mut publisher, subscriber) = broadcast::new("");
+
+        let session = moq_transport::session::Client::publisher(session, subscriber)
+            .await
+            .context("failed to create MoQ Transport session")?;
+
+        // let publisher = publisher
+        //     .create_track(&config.track)
+        //     .context("failed to create clock track")?;
+
+        Ok(())
+    }
+
+    fn set_uri(self: &MoqSink, url_str: Option<&str>) -> Result<(), glib::Error> {
+        let state = self.state.lock().unwrap();
+
+        if let State::Started { .. } = *state {
+            return Err(glib::Error::new(
+                gst::URIError::BadState,
+                "Cannot set URI on a started MoqSink",
+            ));
+        }
+
+        let mut url = self.url.lock().unwrap();
+
+        if url_str.is_none() {
+            *url = None;
+            return Ok(());
+        }
+
+        gst::debug!(CAT, imp: self, "Setting uri to {:?}", url_str);
+
+        let url_str = url_str.unwrap();
+        match parse_relay_url(url_str) {
+            Ok(relayUrl) => {
+                *url = Some(relayUrl);
+                Ok(())
+            }
+            Err(_) => Err(glib::Error::new(
+                gst::URIError::BadUri,
+                "Could not parse URI",
+            )),
+        }
+    }
 }
 
 #[glib::object_subclass]
 impl ObjectSubclass for MoqSink {
     const NAME: &'static str = ELEMENT_CLASS_NAME;
     type Type = super::MoqSink;
-    type ParentType = gst::Element;
+    type ParentType = gst_base::BaseSink;
 
     type Interfaces = (gst::URIHandler);
 

gst-warp-sink/src/relayurl.rs

@@ -1,3 +1,4 @@
+use url::Url;
 #[derive(Clone)]
 pub struct RelayUrl {
     pub host: String,
@@ -10,3 +11,15 @@ impl ToString for RelayUrl {
         format!("https://{}:{}/{}", self.host, self.port, self.name)
     }
 }
+
+pub fn parse_relay_url(url_str: &str) -> Result<Url, String> {
+    let url = Url::try_from(s).map_err(|e| e.to_string())?;
+    
+    //TODO: I know this is redundant, but this might come in handy in the future
+    // Make sure the scheme is moq
+    if url.scheme() != "https" {
+        return Err("url scheme must be https:// for WebTransport".to_string());
+    }
+
+    Ok(url)
+}