1 files changed, 46 insertions, 24 deletions

diff --git a/client-native-export-track/src/main.rs b/client-native-export-track/src/main.rs
index f4dffd6..191d344 100644
--- a/client-native-export-track/src/main.rs
+++ b/client-native-export-track/src/main.rs
@@ -20,14 +20,18 @@ use client_native_lib::{
 use log::{debug, error, info, warn};
 use std::{
     io::{stdout, Write},
-    sync::Arc,
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    },
     time::Duration,
 };
 
 fn main() {
     env_logger::builder()
-        .filter_module("rift", log::LevelFilter::Info)
+        .filter_module("keks_meet_export_track", log::LevelFilter::Info)
         .filter_module("client_native_lib", log::LevelFilter::Info)
+        .filter_module("webrtc", log::LevelFilter::Error)
         .parse_env("LOG")
         .init();
     tokio::runtime::Builder::new_multi_thread()
@@ -38,6 +42,7 @@ fn main() {
 }
 
 #[derive(Parser, Clone)]
+/// exports any kind of track from a keks-meet conference.
 pub struct Args {
     /// keks-meet server used for establishing p2p connection
     #[clap(long, default_value = "wss://meet.metamuffin.org")]
@@ -48,6 +53,9 @@ pub struct Args {
     /// pre-shared secret (aka. room name)
     #[clap(short, long)]
     secret: String,
+    /// interval to send "picture loss indicator" to the remote
+    #[clap(long)]
+    pli_interval: Option<f64>,
 }
 
 async fn run() {
@@ -61,6 +69,7 @@ async fn run() {
         },
         Arc::new(Handler {
             _args: Arc::new(args.clone()),
+            requested_track: Arc::new(AtomicBool::new(false)),
         }),
     )
     .await;
@@ -75,6 +84,7 @@ async fn run() {
 #[derive(Clone)]
 struct Handler {
     _args: Arc<Args>,
+    requested_track: Arc<AtomicBool>,
 }
 
 impl EventHandler for Handler {
@@ -92,9 +102,13 @@ impl EventHandler for Handler {
         info: client_native_lib::protocol::ProvideInfo,
     ) -> DynFut<()> {
         let id = info.id.clone();
+        let r = self.requested_track.clone();
         Box::pin(async move {
             if info.kind == "track" {
-                peer.request_resource(id).await;
+                info!("track of interest is provided, requesting");
+                if !r.swap(true, Ordering::Relaxed) {
+                    peer.request_resource(id).await;
+                }
             }
         })
     }
@@ -108,33 +122,41 @@ impl EventHandler for Handler {
         _resource: &ProvideInfo,
         channel: TransportChannel,
     ) -> client_native_lib::DynFut<()> {
-        // let resource = resource.clone();
-        // let s = self.clone();
         let peer = Arc::downgrade(&peer);
+        let args = Arc::downgrade(&self._args);
         Box::pin(async move {
             match channel {
                 TransportChannel::Track(track) => {
-                    let media_ssrc = track.ssrc();
-                    let peer = peer.clone();
-                    tokio::spawn(async move {
-                        loop {
-                            tokio::time::sleep(Duration::from_secs(3)).await;
-                            let peer = peer.upgrade().unwrap();
-                            let r = peer
-                                .peer_connection
-                                .write_rtcp(&[Box::new(PictureLossIndication {
-                                    sender_ssrc: 0,
-                                    media_ssrc,
-                                })])
-                                .await;
-                            if r.is_err() {
-                                break;
+                    let args = args.upgrade().unwrap();
+                    let peer = peer.upgrade().unwrap();
+
+                    info!("got track remote!");
+                    if let Some(pli_interval) = args.pli_interval {
+                        let media_ssrc = track.ssrc();
+                        let peer = peer.clone();
+                        tokio::spawn(async move {
+                            loop {
+                                tokio::time::sleep(Duration::from_secs_f64(pli_interval)).await;
+                                debug!("sending pli");
+                                let r = peer
+                                    .peer_connection
+                                    .write_rtcp(&[Box::new(PictureLossIndication {
+                                        sender_ssrc: 0,
+                                        media_ssrc,
+                                    })])
+                                    .await;
+                                if r.is_err() {
+                                    break;
+                                }
                             }
-                            debug!("trigger keyframe");
-                        }
-                    });
+                        });
+                    }
 
-                    export(track).await.unwrap();
+                    if let Err(e) = export(track.clone()).await {
+                        error!("export failed: {e}")
+                    }
+                    info!("stopping, telling the remote to stop too.");
+                    peer.request_stop_resource(track.stream_id().await).await;
                 }
                 TransportChannel::DataChannel(_) => warn!("wrong type"),
             }