init

gstreamer/src/README.md

@@ -0,0 +1,51 @@
+To be used as follows:
+
+```rust
+use gst::prelude::*;
+
+fn main() {
+    // Initialize GStreamer
+    gst::init().unwrap();
+
+    // Create the elements
+    let source = gst::ElementFactory::make("videotestsrc", Some("source")).unwrap();
+    let encoder = gst::ElementFactory::make("x264enc", Some("encoder")).unwrap();
+    let muxer = gst::ElementFactory::make("fmp4mux", Some("muxer")).unwrap();
+    let sink = gst::ElementFactory::make("warpsink", Some("sink")).unwrap();
+
+    // Create an empty pipeline
+    let pipeline = gst::Pipeline::new(Some("pipeline"));
+
+    // Build the pipeline
+    pipeline.add_many(&[&source, &encoder, &muxer, &sink]).unwrap();
+    gst::Element::link_many(&[&source, &encoder, &muxer, &sink]).unwrap();
+
+    // Start playing
+    pipeline.set_state(gst::State::Playing).unwrap();
+
+    // Wait until error or EOS
+    let bus = pipeline.bus().unwrap();
+    for msg in bus.iter_timed(gst::CLOCK_TIME_NONE) {
+        use gst::MessageView;
+
+        match msg.view() {
+            MessageView::Error(err) => {
+                eprintln!(
+                    "Error from {:?}: {} ({:?})",
+                    err.src().map(|s| s.path_string()),
+                    err.error(),
+                    err.debug()
+                );
+                break;
+            }
+            MessageView::Eos(..) => break,
+            _ => (),
+        }
+    }
+
+    // Clean up
+    pipeline.set_state(gst::State::Null).unwrap();
+}
+```
+
+

gstreamer/src/fmp4mux/LICENSE.md

@@ -0,0 +1,373 @@
+Mozilla Public License Version 2.0
+==================================
+
+1. Definitions
+--------------
+
+1.1. "Contributor"
+    means each individual or legal entity that creates, contributes to
+    the creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+    means the combination of the Contributions of others (if any) used
+    by a Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+    means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+    means Source Code Form to which the initial Contributor has attached
+    the notice in Exhibit A, the Executable Form of such Source Code
+    Form, and Modifications of such Source Code Form, in each case
+    including portions thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+    means
+
+    (a) that the initial Contributor has attached the notice described
+        in Exhibit B to the Covered Software; or
+
+    (b) that the Covered Software was made available under the terms of
+        version 1.1 or earlier of the License, but not also under the
+        terms of a Secondary License.
+
+1.6. "Executable Form"
+    means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+    means a work that combines Covered Software with other material, in 
+    a separate file or files, that is not Covered Software.
+
+1.8. "License"
+    means this document.
+
+1.9. "Licensable"
+    means having the right to grant, to the maximum extent possible,
+    whether at the time of the initial grant or subsequently, any and
+    all of the rights conveyed by this License.
+
+1.10. "Modifications"
+    means any of the following:
+
+    (a) any file in Source Code Form that results from an addition to,
+        deletion from, or modification of the contents of Covered
+        Software; or
+
+    (b) any new file in Source Code Form that contains any Covered
+        Software.
+
+1.11. "Patent Claims" of a Contributor
+    means any patent claim(s), including without limitation, method,
+    process, and apparatus claims, in any patent Licensable by such
+    Contributor that would be infringed, but for the grant of the
+    License, by the making, using, selling, offering for sale, having
+    made, import, or transfer of either its Contributions or its
+    Contributor Version.
+
+1.12. "Secondary License"
+    means either the GNU General Public License, Version 2.0, the GNU
+    Lesser General Public License, Version 2.1, the GNU Affero General
+    Public License, Version 3.0, or any later versions of those
+    licenses.
+
+1.13. "Source Code Form"
+    means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+    means an individual or a legal entity exercising rights under this
+    License. For legal entities, "You" includes any entity that
+    controls, is controlled by, or is under common control with You. For
+    purposes of this definition, "control" means (a) the power, direct
+    or indirect, to cause the direction or management of such entity,
+    whether by contract or otherwise, or (b) ownership of more than
+    fifty percent (50%) of the outstanding shares or beneficial
+    ownership of such entity.
+
+2. License Grants and Conditions
+--------------------------------
+
+2.1. Grants
+
+Each Contributor hereby grants You a world-wide, royalty-free,
+non-exclusive license:
+
+(a) under intellectual property rights (other than patent or trademark)
+    Licensable by such Contributor to use, reproduce, make available,
+    modify, display, perform, distribute, and otherwise exploit its
+    Contributions, either on an unmodified basis, with Modifications, or
+    as part of a Larger Work; and
+
+(b) under Patent Claims of such Contributor to make, use, sell, offer
+    for sale, have made, import, and otherwise transfer either its
+    Contributions or its Contributor Version.
+
+2.2. Effective Date
+
+The licenses granted in Section 2.1 with respect to any Contribution
+become effective for each Contribution on the date the Contributor first
+distributes such Contribution.
+
+2.3. Limitations on Grant Scope
+
+The licenses granted in this Section 2 are the only rights granted under
+this License. No additional rights or licenses will be implied from the
+distribution or licensing of Covered Software under this License.
+Notwithstanding Section 2.1(b) above, no patent license is granted by a
+Contributor:
+
+(a) for any code that a Contributor has removed from Covered Software;
+    or
+
+(b) for infringements caused by: (i) Your and any other third party's
+    modifications of Covered Software, or (ii) the combination of its
+    Contributions with other software (except as part of its Contributor
+    Version); or
+
+(c) under Patent Claims infringed by Covered Software in the absence of
+    its Contributions.
+
+This License does not grant any rights in the trademarks, service marks,
+or logos of any Contributor (except as may be necessary to comply with
+the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+No Contributor makes additional grants as a result of Your choice to
+distribute the Covered Software under a subsequent version of this
+License (see Section 10.2) or under the terms of a Secondary License (if
+permitted under the terms of Section 3.3).
+
+2.5. Representation
+
+Each Contributor represents that the Contributor believes its
+Contributions are its original creation(s) or it has sufficient rights
+to grant the rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+This License is not intended to limit any rights You have under
+applicable copyright doctrines of fair use, fair dealing, or other
+equivalents.
+
+2.7. Conditions
+
+Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
+in Section 2.1.
+
+3. Responsibilities
+-------------------
+
+3.1. Distribution of Source Form
+
+All distribution of Covered Software in Source Code Form, including any
+Modifications that You create or to which You contribute, must be under
+the terms of this License. You must inform recipients that the Source
+Code Form of the Covered Software is governed by the terms of this
+License, and how they can obtain a copy of this License. You may not
+attempt to alter or restrict the recipients' rights in the Source Code
+Form.
+
+3.2. Distribution of Executable Form
+
+If You distribute Covered Software in Executable Form then:
+
+(a) such Covered Software must also be made available in Source Code
+    Form, as described in Section 3.1, and You must inform recipients of
+    the Executable Form how they can obtain a copy of such Source Code
+    Form by reasonable means in a timely manner, at a charge no more
+    than the cost of distribution to the recipient; and
+
+(b) You may distribute such Executable Form under the terms of this
+    License, or sublicense it under different terms, provided that the
+    license for the Executable Form does not attempt to limit or alter
+    the recipients' rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+You may create and distribute a Larger Work under terms of Your choice,
+provided that You also comply with the requirements of this License for
+the Covered Software. If the Larger Work is a combination of Covered
+Software with a work governed by one or more Secondary Licenses, and the
+Covered Software is not Incompatible With Secondary Licenses, this
+License permits You to additionally distribute such Covered Software
+under the terms of such Secondary License(s), so that the recipient of
+the Larger Work may, at their option, further distribute the Covered
+Software under the terms of either this License or such Secondary
+License(s).
+
+3.4. Notices
+
+You may not remove or alter the substance of any license notices
+(including copyright notices, patent notices, disclaimers of warranty,
+or limitations of liability) contained within the Source Code Form of
+the Covered Software, except that You may alter any license notices to
+the extent required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+You may choose to offer, and to charge a fee for, warranty, support,
+indemnity or liability obligations to one or more recipients of Covered
+Software. However, You may do so only on Your own behalf, and not on
+behalf of any Contributor. You must make it absolutely clear that any
+such warranty, support, indemnity, or liability obligation is offered by
+You alone, and You hereby agree to indemnify every Contributor for any
+liability incurred by such Contributor as a result of warranty, support,
+indemnity or liability terms You offer. You may include additional
+disclaimers of warranty and limitations of liability specific to any
+jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+---------------------------------------------------
+
+If it is impossible for You to comply with any of the terms of this
+License with respect to some or all of the Covered Software due to
+statute, judicial order, or regulation then You must: (a) comply with
+the terms of this License to the maximum extent possible; and (b)
+describe the limitations and the code they affect. Such description must
+be placed in a text file included with all distributions of the Covered
+Software under this License. Except to the extent prohibited by statute
+or regulation, such description must be sufficiently detailed for a
+recipient of ordinary skill to be able to understand it.
+
+5. Termination
+--------------
+
+5.1. The rights granted under this License will terminate automatically
+if You fail to comply with any of its terms. However, if You become
+compliant, then the rights granted under this License from a particular
+Contributor are reinstated (a) provisionally, unless and until such
+Contributor explicitly and finally terminates Your grants, and (b) on an
+ongoing basis, if such Contributor fails to notify You of the
+non-compliance by some reasonable means prior to 60 days after You have
+come back into compliance. Moreover, Your grants from a particular
+Contributor are reinstated on an ongoing basis if such Contributor
+notifies You of the non-compliance by some reasonable means, this is the
+first time You have received notice of non-compliance with this License
+from such Contributor, and You become compliant prior to 30 days after
+Your receipt of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+infringement claim (excluding declaratory judgment actions,
+counter-claims, and cross-claims) alleging that a Contributor Version
+directly or indirectly infringes any patent, then the rights granted to
+You by any and all Contributors for the Covered Software under Section
+2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all
+end user license agreements (excluding distributors and resellers) which
+have been validly granted by You or Your distributors under this License
+prior to termination shall survive termination.
+
+************************************************************************
+*                                                                      *
+*  6. Disclaimer of Warranty                                           *
+*  -------------------------                                           *
+*                                                                      *
+*  Covered Software is provided under this License on an "as is"       *
+*  basis, without warranty of any kind, either expressed, implied, or  *
+*  statutory, including, without limitation, warranties that the       *
+*  Covered Software is free of defects, merchantable, fit for a        *
+*  particular purpose or non-infringing. The entire risk as to the     *
+*  quality and performance of the Covered Software is with You.        *
+*  Should any Covered Software prove defective in any respect, You     *
+*  (not any Contributor) assume the cost of any necessary servicing,   *
+*  repair, or correction. This disclaimer of warranty constitutes an   *
+*  essential part of this License. No use of any Covered Software is   *
+*  authorized under this License except under this disclaimer.         *
+*                                                                      *
+************************************************************************
+
+************************************************************************
+*                                                                      *
+*  7. Limitation of Liability                                          *
+*  --------------------------                                          *
+*                                                                      *
+*  Under no circumstances and under no legal theory, whether tort      *
+*  (including negligence), contract, or otherwise, shall any           *
+*  Contributor, or anyone who distributes Covered Software as          *
+*  permitted above, be liable to You for any direct, indirect,         *
+*  special, incidental, or consequential damages of any character      *
+*  including, without limitation, damages for lost profits, loss of    *
+*  goodwill, work stoppage, computer failure or malfunction, or any    *
+*  and all other commercial damages or losses, even if such party      *
+*  shall have been informed of the possibility of such damages. This   *
+*  limitation of liability shall not apply to liability for death or   *
+*  personal injury resulting from such party's negligence to the       *
+*  extent applicable law prohibits such limitation. Some               *
+*  jurisdictions do not allow the exclusion or limitation of           *
+*  incidental or consequential damages, so this exclusion and          *
+*  limitation may not apply to You.                                    *
+*                                                                      *
+************************************************************************
+
+8. Litigation
+-------------
+
+Any litigation relating to this License may be brought only in the
+courts of a jurisdiction where the defendant maintains its principal
+place of business and such litigation shall be governed by laws of that
+jurisdiction, without reference to its conflict-of-law provisions.
+Nothing in this Section shall prevent a party's ability to bring
+cross-claims or counter-claims.
+
+9. Miscellaneous
+----------------
+
+This License represents the complete agreement concerning the subject
+matter hereof. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent
+necessary to make it enforceable. Any law or regulation which provides
+that the language of a contract shall be construed against the drafter
+shall not be used to construe this License against a Contributor.
+
+10. Versions of the License
+---------------------------
+
+10.1. New Versions
+
+Mozilla Foundation is the license steward. Except as provided in Section
+10.3, no one other than the license steward has the right to modify or
+publish new versions of this License. Each version will be given a
+distinguishing version number.
+
+10.2. Effect of New Versions
+
+You may distribute the Covered Software under the terms of the version
+of the License under which You originally received the Covered Software,
+or under the terms of any subsequent version published by the license
+steward.
+
+10.3. Modified Versions
+
+If you create software not governed by this License, and you want to
+create a new license for such software, you may create and use a
+modified version of this License if you rename the license and remove
+any references to the name of the license steward (except to note that
+such modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary
+Licenses
+
+If You choose to distribute Source Code Form that is Incompatible With
+Secondary Licenses under the terms of this version of the License, the
+notice described in Exhibit B of this License must be attached.
+
+Exhibit A - Source Code Form License Notice
+-------------------------------------------
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular
+file, then You may include the notice in a location (such as a LICENSE
+file in a relevant directory) where a recipient would be likely to look
+for such a notice.
+
+You may add additional accurate notices of copyright ownership.
+
+Exhibit B - "Incompatible With Secondary Licenses" Notice
+---------------------------------------------------------
+
+  This Source Code Form is "Incompatible With Secondary Licenses", as
+  defined by the Mozilla Public License, v. 2.0.

gstreamer/src/fmp4mux/README.md

@@ -0,0 +1 @@
+https://github.com/sdroege/gst-plugin-rs/tree/main/mux/fmp4

gstreamer/src/fmp4mux/mod.rs

@@ -0,0 +1,208 @@
+// Copyright (C) 2021 Sebastian Dröge <sebastian@centricular.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla Public License, v2.0.
+// If a copy of the MPL was not distributed with this file, You can obtain one at
+// <https://mozilla.org/MPL/2.0/>.
+//
+// SPDX-License-Identifier: MPL-2.0
+
+use gst::glib;
+use gst::prelude::*;
+
+mod boxes;
+mod imp;
+
+glib::wrapper! {
+    pub(crate) struct FMP4MuxPad(ObjectSubclass<imp::FMP4MuxPad>) @extends gst_base::AggregatorPad, gst::Pad, gst::Object;
+}
+
+glib::wrapper! {
+    pub(crate) struct FMP4Mux(ObjectSubclass<imp::FMP4Mux>) @extends gst_base::Aggregator, gst::Element, gst::Object;
+}
+
+glib::wrapper! {
+    pub(crate) struct ISOFMP4Mux(ObjectSubclass<imp::ISOFMP4Mux>) @extends FMP4Mux, gst_base::Aggregator, gst::Element, gst::Object;
+}
+
+glib::wrapper! {
+    pub(crate) struct CMAFMux(ObjectSubclass<imp::CMAFMux>) @extends FMP4Mux, gst_base::Aggregator, gst::Element, gst::Object;
+}
+
+glib::wrapper! {
+    pub(crate) struct DASHMP4Mux(ObjectSubclass<imp::DASHMP4Mux>) @extends FMP4Mux, gst_base::Aggregator, gst::Element, gst::Object;
+}
+
+glib::wrapper! {
+    pub(crate) struct ONVIFFMP4Mux(ObjectSubclass<imp::ONVIFFMP4Mux>) @extends FMP4Mux, gst_base::Aggregator, gst::Element, gst::Object;
+}
+
+pub fn register(plugin: &gst::Plugin) -> Result<(), glib::BoolError> {
+    #[cfg(feature = "doc")]
+    {
+        FMP4Mux::static_type().mark_as_plugin_api(gst::PluginAPIFlags::empty());
+        FMP4MuxPad::static_type().mark_as_plugin_api(gst::PluginAPIFlags::empty());
+        HeaderUpdateMode::static_type().mark_as_plugin_api(gst::PluginAPIFlags::empty());
+    }
+    gst::Element::register(
+        Some(plugin),
+        "isofmp4mux",
+        gst::Rank::PRIMARY,
+        ISOFMP4Mux::static_type(),
+    )?;
+    gst::Element::register(
+        Some(plugin),
+        "cmafmux",
+        gst::Rank::PRIMARY,
+        CMAFMux::static_type(),
+    )?;
+    gst::Element::register(
+        Some(plugin),
+        "dashmp4mux",
+        gst::Rank::PRIMARY,
+        DASHMP4Mux::static_type(),
+    )?;
+    gst::Element::register(
+        Some(plugin),
+        "onviffmp4mux",
+        gst::Rank::PRIMARY,
+        ONVIFFMP4Mux::static_type(),
+    )?;
+
+    Ok(())
+}
+
+#[derive(Debug)]
+pub(crate) struct HeaderConfiguration {
+    variant: Variant,
+    update: bool,
+
+    /// Pre-defined movie timescale if not 0.
+    movie_timescale: u32,
+
+    /// First caps must be the video/reference stream. Must be in the order the tracks are going to
+    /// be used later for the fragments too.
+    streams: Vec<HeaderStream>,
+
+    write_mehd: bool,
+    duration: Option<gst::ClockTime>,
+
+    /// Start UTC time in ONVIF mode.
+    /// Since Jan 1 1601 in 100ns units.
+    start_utc_time: Option<u64>,
+}
+
+#[derive(Debug)]
+pub(crate) struct HeaderStream {
+    /// Caps of this stream
+    caps: gst::Caps,
+
+    /// Set if this is an intra-only stream
+    delta_frames: DeltaFrames,
+
+    /// Pre-defined trak timescale if not 0.
+    trak_timescale: u32,
+}
+
+#[derive(Debug)]
+pub(crate) struct FragmentHeaderConfiguration<'a> {
+    variant: Variant,
+
+    /// Sequence number for this fragment.
+    sequence_number: u32,
+
+    /// If this is a full fragment or only a chunk.
+    chunk: bool,
+
+    streams: &'a [FragmentHeaderStream],
+    buffers: &'a [Buffer],
+}
+
+#[derive(Debug)]
+pub(crate) struct FragmentHeaderStream {
+    /// Caps of this stream
+    caps: gst::Caps,
+
+    /// Set if this is an intra-only stream
+    delta_frames: DeltaFrames,
+
+    /// Pre-defined trak timescale if not 0.
+    trak_timescale: u32,
+
+    /// Start time of this fragment
+    ///
+    /// `None` if this stream has no buffers in this fragment.
+    start_time: Option<gst::ClockTime>,
+}
+
+#[derive(Debug, Copy, Clone)]
+pub(crate) enum DeltaFrames {
+    /// Only single completely decodable frames
+    IntraOnly,
+    /// Frames may depend on past frames
+    PredictiveOnly,
+    /// Frames may depend on past or future frames
+    Bidirectional,
+}
+
+impl DeltaFrames {
+    /// Whether dts is required to order buffers differently from presentation order
+    pub(crate) fn requires_dts(&self) -> bool {
+        matches!(self, Self::Bidirectional)
+    }
+    /// Whether this coding structure does not allow delta flags on buffers
+    pub(crate) fn intra_only(&self) -> bool {
+        matches!(self, Self::IntraOnly)
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct Buffer {
+    /// Track index
+    idx: usize,
+
+    /// Actual buffer
+    buffer: gst::Buffer,
+
+    /// Timestamp
+    timestamp: gst::ClockTime,
+
+    /// Sample duration
+    duration: gst::ClockTime,
+
+    /// Composition time offset
+    composition_time_offset: Option<i64>,
+}
+
+#[allow(clippy::upper_case_acronyms)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum Variant {
+    ISO,
+    CMAF,
+    DASH,
+    ONVIF,
+}
+
+impl Variant {
+    pub(crate) fn is_single_stream(self) -> bool {
+        match self {
+            Variant::ISO | Variant::ONVIF => false,
+            Variant::CMAF | Variant::DASH => true,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct FragmentOffset {
+    time: gst::ClockTime,
+    offset: u64,
+}
+
+#[allow(clippy::upper_case_acronyms)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, glib::Enum)]
+#[repr(i32)]
+#[enum_type(name = "GstFMP4MuxHeaderUpdateMode")]
+pub(crate) enum HeaderUpdateMode {
+    None,
+    Rewrite,
+    Update,
+}

gstreamer/src/lib.rs

@@ -0,0 +1,39 @@
+// Copyright (C) 2021 Sebastian Dröge <sebastian@centricular.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla Public License, v2.0.
+// If a copy of the MPL was not distributed with this file, You can obtain one at
+// <https://mozilla.org/MPL/2.0/>.
+//
+// SPDX-License-Identifier: MPL-2.0
+#![allow(clippy::non_send_fields_in_send_ty, unused_doc_comments)]
+
+/**
+ * plugin-fmp4:
+ *
+ * Since: plugins-rs-0.8.0
+ */
+use gst::glib;
+
+mod fmp4mux;
+mod warpsink;
+mod waylandsrc;
+
+fn plugin_init(plugin: &gst::Plugin) -> Result<(), glib::BoolError> {
+    waylandsrc::register(plugin)?;
+    fmp4mux::register(plugin)?;
+    warpsink::register(plugin)?;
+    Ok(())
+}
+
+gst::plugin_define!(
+    warp,
+    env!("CARGO_PKG_DESCRIPTION"),
+    plugin_init,
+    concat!(env!("CARGO_PKG_VERSION"), "-", env!("COMMIT_ID")),
+    // FIXME: MPL-2.0 is only allowed since 1.18.3 (as unknown) and 1.20 (as known)
+    "MPL",
+    env!("CARGO_PKG_NAME"),
+    env!("CARGO_PKG_NAME"),
+    env!("CARGO_PKG_REPOSITORY"),
+    env!("BUILD_REL_DATE")
+);

gstreamer/src/warpsink/imp.rs

@@ -0,0 +1,107 @@
+use gst::glib;
+use gst::prelude::*;
+use gst::subclass::prelude::*;
+use gst_base::subclass::prelude::*;
+use gst_base::BaseSink;
+use once_cell::sync::Lazy;
+use std::sync::Mutex;
+
+// Define the plugin's instance structure with a URL property.
+pub struct MoqSink {
+    sink: gst_base::BaseSink,
+    url: Mutex<Option<String>>, // Store the URL property value
+    // Add additional fields for moq_transport as needed.
+}
+
+// Implement the GObject subclass for our sink.
+#[glib::object_subclass]
+impl ObjectSubclass for MoqSink {
+    const NAME: &'static str = "MoqSink";
+    type Type = super::MoqSink;
+    type ParentType = BaseSink;
+}
+
+// Implement the GstObject trait for our sink to set up the metadata.
+impl GstObjectImpl for MoqSink {}
+
+// Implement the Element trait for our sink. This is where we can add pads and set up
+// the element's functionality.
+impl ElementImpl for MoqSink {
+    // Define metadata for the element.
+    fn metadata() -> Option<&'static gst::subclass::ElementMetadata> {
+        static ELEMENT_METADATA: Lazy<gst::subclass::ElementMetadata> = Lazy::new(|| {
+            gst::subclass::ElementMetadata::new(
+                "MoQ Sink",
+                "Sink/Network",
+                "Send data over QUIC using the MoQ protocol",
+                "Wanjohi Ryan<wanjohi.ryan@example.com>",
+            )
+        });
+        Some(&*ELEMENT_METADATA)
+    }
+}
+
+// Implement the properties and their behavior for the sink.
+impl ObjectImpl for MoqSink {
+    fn properties() -> &'static [glib::ParamSpec] {
+        static PROPERTIES: Lazy<Vec<glib::ParamSpec>> = Lazy::new(|| {
+            vec![
+                glib::ParamSpecString::new(
+                    "url",
+                    "URL",
+                    "URL to send data to",
+                    None, // Default value
+                    glib::ParamFlags::READWRITE,
+                ),
+            ]
+        });
+
+        PROPERTIES.as_ref()
+    }
+
+    fn set_property(&self, _id: usize, value: &glib::Value, pspec: &glib::ParamSpec) {
+        match pspec.name() {
+            "url" => {
+                let mut url = self.url.lock().unwrap();
+                *url = value.get().expect("Type checked upstream");
+            }
+            _ => unimplemented!(),
+        }
+    }
+
+    fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
+        match pspec.name() {
+            "url" => {
+                let url = self.url.lock().unwrap();
+                url.as_ref().to_value()
+            }
+            _ => unimplemented!(),
+        }
+    }
+}
+
+// Implement the BaseSink trait for our sink. This is where most of the sink logic is implemented.
+impl BaseSinkImpl for MoqSink {
+    fn start(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
+        // Initialize moq_transport here.
+        Ok(())
+    }
+
+    fn stop(&self, element: &Self::Type) -> Result<(), gst::ErrorMessage> {
+        // Clean up moq_transport here.
+        Ok(())
+    }
+
+    fn render(&self, element: &Self::Type, buffer: &gst::Buffer) -> Result<gst::FlowSuccess, gst::FlowError> {
+        // Send buffer data over QUIC using moq_transport.
+        // from the provided `imp.rs` code. For simplicity, we'll just print the buffer size.
+        
+        let size = buffer.size();
+        println!("Received buffer of size {}", size);
+
+        // You would then send the buffer data over QUIC using moq_transport.
+        // This part is omitted and should be implemented based on your transport protocol.
+
+        Ok(gst::FlowSuccess::Ok)
+    }
+}

gstreamer/src/warpsink/mod.rs

@@ -0,0 +1,17 @@
+use gst::glib;
+use gst::prelude::*;
+
+mod imp;
+
+glib::wrapper! {
+    pub struct MoqSink(ObjectSubclass<imp::MoqSink>) @extends gst_base::BaseSink, gst::Element, gst::Object;
+}
+
+pub fn register(plugin: &gst::Plugin) -> Result<(), glib::BoolError> {
+    gst::Element::register(
+        Some(plugin),
+        "moqsink",
+        gst::Rank::None,
+        MoqSink::static_type(),
+    )
+}

gstreamer/src/wayland/imp.rs

@@ -0,0 +1,282 @@
+use std::sync::Mutex;
+
+use gst::message::Application;
+use gst_video::{VideoCapsBuilder, VideoFormat};
+
+use gst::subclass::prelude::*;
+use gst::{glib, Event, Fraction};
+use gst::{
+    glib::{once_cell::sync::Lazy, ValueArray},
+    LibraryError,
+};
+use gst::{prelude::*, Structure};
+
+use gst_base::subclass::base_src::CreateSuccess;
+use gst_base::subclass::prelude::*;
+use gst_base::traits::BaseSrcExt;
+
+use waylanddisplaycore::WaylandDisplay;
+use tracing_subscriber::layer::SubscriberExt;
+use tracing_subscriber::Registry;
+
+use crate::utils::{GstLayer, CAT};
+
+pub struct WaylandDisplaySrc {
+    state: Mutex<Option<State>>,
+    settings: Mutex<Settings>,
+}
+
+impl Default for WaylandDisplaySrc {
+    fn default() -> Self {
+        WaylandDisplaySrc {
+            state: Mutex::new(None),
+            settings: Mutex::new(Settings::default()),
+        }
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct Settings {
+    render_node: Option<String>,
+}
+
+pub struct State {
+    display: WaylandDisplay,
+}
+
+#[glib::object_subclass]
+impl ObjectSubclass for WaylandDisplaySrc {
+    const NAME: &'static str = "GstWaylandDisplaySrc";
+    type Type = super::WaylandDisplaySrc;
+    type ParentType = gst_base::PushSrc;
+    type Interfaces = ();
+}
+
+impl ObjectImpl for WaylandDisplaySrc {
+    fn properties() -> &'static [glib::ParamSpec] {
+        static PROPERTIES: Lazy<Vec<glib::ParamSpec>> = Lazy::new(|| {
+            vec![glib::ParamSpecString::builder("render-node")
+                .nick("DRM Render Node")
+                .blurb("DRM Render Node to use (e.g. /dev/dri/renderD128")
+                .construct()
+                .build()]
+        });
+
+        PROPERTIES.as_ref()
+    }
+
+    fn set_property(&self, _id: usize, value: &glib::Value, pspec: &glib::ParamSpec) {
+        match pspec.name() {
+            "render-node" => {
+                let mut settings = self.settings.lock().unwrap();
+                settings.render_node = value
+                    .get::<Option<String>>()
+                    .expect("Type checked upstream");
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
+        match pspec.name() {
+            "render-node" => {
+                let settings = self.settings.lock().unwrap();
+                settings
+                    .render_node
+                    .clone()
+                    .unwrap_or_else(|| String::from("/dev/dri/renderD128"))
+                    .to_value()
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    fn constructed(&self) {
+        self.parent_constructed();
+
+        let obj = self.obj();
+        obj.set_element_flags(gst::ElementFlags::SOURCE);
+        obj.set_live(true);
+        obj.set_format(gst::Format::Time);
+        obj.set_automatic_eos(false);
+        obj.set_do_timestamp(true);
+    }
+}
+
+impl GstObjectImpl for WaylandDisplaySrc {}
+
+impl ElementImpl for WaylandDisplaySrc {
+    fn metadata() -> Option<&'static gst::subclass::ElementMetadata> {
+        static ELEMENT_METADATA: Lazy<gst::subclass::ElementMetadata> = Lazy::new(|| {
+            gst::subclass::ElementMetadata::new(
+                "Wayland display source",
+                "Source/Video",
+                "GStreamer video src running a wayland compositor",
+                "Victoria Brekenfeld <wayland@drakulix.de>",
+            )
+        });
+
+        Some(&*ELEMENT_METADATA)
+    }
+
+    fn pad_templates() -> &'static [gst::PadTemplate] {
+        static PAD_TEMPLATES: Lazy<Vec<gst::PadTemplate>> = Lazy::new(|| {
+            let caps = gst_video::VideoCapsBuilder::new()
+                .format(VideoFormat::Rgbx)
+                .height_range(..i32::MAX)
+                .width_range(..i32::MAX)
+                .framerate_range(Fraction::new(1, 1)..Fraction::new(i32::MAX, 1))
+                .build();
+            let src_pad_template = gst::PadTemplate::new(
+                "src",
+                gst::PadDirection::Src,
+                gst::PadPresence::Always,
+                &caps,
+            )
+            .unwrap();
+
+            vec![src_pad_template]
+        });
+
+        PAD_TEMPLATES.as_ref()
+    }
+
+    fn change_state(
+        &self,
+        transition: gst::StateChange,
+    ) -> Result<gst::StateChangeSuccess, gst::StateChangeError> {
+        let res = self.parent_change_state(transition);
+        match res {
+            Ok(gst::StateChangeSuccess::Success) => {
+                if transition.next() == gst::State::Paused {
+                    // this is a live source
+                    Ok(gst::StateChangeSuccess::NoPreroll)
+                } else {
+                    Ok(gst::StateChangeSuccess::Success)
+                }
+            }
+            x => x,
+        }
+    }
+
+    fn query(&self, query: &mut gst::QueryRef) -> bool {
+        ElementImplExt::parent_query(self, query)
+    }
+}
+
+impl BaseSrcImpl for WaylandDisplaySrc {
+    fn query(&self, query: &mut gst::QueryRef) -> bool {
+        BaseSrcImplExt::parent_query(self, query)
+    }
+
+    fn caps(&self, filter: Option<&gst::Caps>) -> Option<gst::Caps> {
+        let mut caps = VideoCapsBuilder::new()
+            .format(VideoFormat::Rgbx)
+            .height_range(..i32::MAX)
+            .width_range(..i32::MAX)
+            .framerate_range(Fraction::new(1, 1)..Fraction::new(i32::MAX, 1))
+            .build();
+
+        if let Some(filter) = filter {
+            caps = caps.intersect(filter);
+        }
+
+        Some(caps)
+    }
+
+    fn negotiate(&self) -> Result<(), gst::LoggableError> {
+        self.parent_negotiate()
+    }
+
+    fn event(&self, event: &Event) -> bool {
+        if event.type_() == gst::EventType::CustomUpstream {
+            let structure = event.structure().expect("Unable to get message structure");
+            if structure.has_name("VirtualDevicesReady") {
+                let mut state = self.state.lock().unwrap();
+                let display = &mut state.as_mut().unwrap().display;
+
+                let paths = structure
+                    .get::<ValueArray>("paths")
+                    .expect("Should contain paths");
+                for value in paths.into_iter() {
+                    let path = value.get::<String>().expect("Paths are strings");
+                    display.add_input_device(path);
+                }
+
+                return true;
+            }
+        }
+        self.parent_event(event)
+    }
+
+    fn set_caps(&self, caps: &gst::Caps) -> Result<(), gst::LoggableError> {
+        let video_info = gst_video::VideoInfo::from_caps(caps).expect("failed to get video info");
+        self.state
+            .lock()
+            .unwrap()
+            .as_mut()
+            .unwrap()
+            .display
+            .set_video_info(video_info);
+
+        self.parent_set_caps(caps)
+    }
+
+    fn start(&self) -> Result<(), gst::ErrorMessage> {
+        let mut state = self.state.lock().unwrap();
+        if state.is_some() {
+            return Ok(());
+        }
+
+        let settings = self.settings.lock().unwrap();
+        let elem = self.obj().upcast_ref::<gst::Element>().to_owned();
+        let subscriber = Registry::default().with(GstLayer);
+
+        let Ok(mut display) = tracing::subscriber::with_default(subscriber, || WaylandDisplay::new(settings.render_node.clone())) else {
+            return Err(gst::error_msg!(LibraryError::Failed, ("Failed to open drm node {}, if you want to utilize software rendering set `render-node=software`.", settings.render_node.as_deref().unwrap_or("/dev/dri/renderD128"))));
+        };
+
+        let mut structure = Structure::builder("wayland.src");
+        for (key, var) in display.env_vars().flat_map(|var| var.split_once("=")) {
+            structure = structure.field(key, var);
+        }
+        let structure = structure.build();
+        if let Err(err) = elem.post_message(Application::builder(structure).src(&elem).build()) {
+            gst::warning!(CAT, "Failed to post environment to gstreamer bus: {}", err);
+        }
+
+        *state = Some(State { display });
+
+        Ok(())
+    }
+
+    fn stop(&self) -> Result<(), gst::ErrorMessage> {
+        let mut state = self.state.lock().unwrap();
+        if let Some(state) = state.take() {
+            let subscriber = Registry::default().with(GstLayer);
+            tracing::subscriber::with_default(subscriber, || std::mem::drop(state.display));
+        }
+        Ok(())
+    }
+
+    fn is_seekable(&self) -> bool {
+        false
+    }
+}
+
+impl PushSrcImpl for WaylandDisplaySrc {
+    fn create(
+        &self,
+        _buffer: Option<&mut gst::BufferRef>,
+    ) -> Result<CreateSuccess, gst::FlowError> {
+        let mut state_guard = self.state.lock().unwrap();
+        let Some(state) = state_guard.as_mut() else {
+            return Err(gst::FlowError::Eos);
+        };
+
+        let subscriber = Registry::default().with(GstLayer);
+        tracing::subscriber::with_default(subscriber, || {
+            state.display.frame().map(CreateSuccess::NewBuffer)
+        })
+    }
+}

gstreamer/src/wayland/mod.rs

@@ -0,0 +1,17 @@
+use gst::glib;
+use gst::prelude::*;
+
+mod imp;
+
+glib::wrapper! {
+    pub struct WaylandDisplaySrc(ObjectSubclass<imp::WaylandDisplaySrc>) @extends gst_base::PushSrc, gst_base::BaseSrc, gst::Element, gst::Object;
+}
+
+pub fn register(plugin: &gst::Plugin) -> Result<(), glib::BoolError> {
+    gst::Element::register(
+        Some(plugin),
+        "waylanddisplaysrc",
+        gst::Rank::Marginal,
+        WaylandDisplaySrc::static_type(),
+    )
+}