@desklink/host 0.5.14 → 0.5.16

package/engine/src/peer.rs

@@ -1190,12 +1190,6 @@ impl VideoPeer {
         lock(&self.path).take()
     }
 
-    /// Stand in for transport-wide feedback that reports a path, for a pipeline under test.
-    #[cfg(test)]
-    pub fn report_path(&self, report: PathReport) {
-        *lock(&self.path) = Some(report);
-    }
-
     /// Take the pending "the far end needs a reference frame" request, if any.
     pub fn take_keyframe_request(&self) -> bool {
         self.wants_keyframe.swap(false, Ordering::SeqCst)
@@ -1239,118 +1233,6 @@ pub(crate) mod tests {
     use super::*;
     use webrtc::media_stream::track_remote::{TrackRemote, TrackRemoteEvent};
 
-    #[test]
-    fn a_standing_queue_is_measured_and_one_frames_burst_is_not() {
-        let epoch = Instant::now();
-        let report = Arc::new(Mutex::new(None));
-        let mut estimator = QueueDelay::new(report.clone(), 20_000_000.0);
-        let mut id = 0u64;
-        // One 1200-byte packet every 10 ms, sent at `ms` and `extra` ms late
-        // over a path with 20 ms of base delay.
-        let mut feed = |from: u64, to: u64, extra: &dyn Fn(u64) -> u64| {
-            let reports: Vec<PacketReport> = (from..to)
-                .step_by(10)
-                .map(|ms| {
-                    id += 1;
-                    PacketReport {
-                        ssrc: 1,
-                        id,
-                        rtp_sequence_number: id as u16,
-                        is_twcc: true,
-                        twcc_sequence_number: id as u16,
-                        size: 1200,
-                        arrived: true,
-                        departure: epoch + Duration::from_millis(ms),
-                        arrival: Some(Duration::from_millis(1_000 + ms + 20 + extra(ms))),
-                        ecn: Default::default(),
-                    }
-                })
-                .collect();
-            estimator.on_reports(epoch + Duration::from_millis(to + 20), &reports);
-            lock(&report).take().expect("a report")
-        };
-
-        let quiet = feed(0, 1000, &|_| 0);
-        assert_eq!(quiet.queue_delay, Duration::ZERO);
-        // 51 packets of 1200 bytes arrived in the last 500 ms, both ends in.
-        assert_eq!(quiet.delivered_kbps, 979);
-        // A frame's burst lifts the packets at its tail, not the ones before.
-        let burst = feed(1000, 1100, &|ms| if ms >= 1070 { 40 } else { 0 });
-        assert_eq!(burst.queue_delay, Duration::ZERO);
-        // A link that drains slower than it is fed lifts every packet: the
-        // queue is the least any packet of the last 200 ms waited.
-        let standing = feed(1100, 1400, &|ms| 30 + (ms - 1100) / 10);
-        assert_eq!(standing.queue_delay, Duration::from_millis(41));
-    }
-
-    struct NoopHandler;
-
-    impl PeerConnectionEventHandler for NoopHandler {}
-
-    async fn answerer(offer: &str) -> Arc<dyn PeerConnection> {
-        answerer_with(offer, vec![vp9_codec()]).await
-    }
-
-    /// A receiver that decodes `codecs`, in its order of preference.
-    pub(crate) async fn answerer_with(
-        offer: &str,
-        codecs: Vec<RTCRtpCodecParameters>,
-    ) -> Arc<dyn PeerConnection> {
-        let mut media_engine = MediaEngine::default();
-        for codec in codecs {
-            media_engine
-                .register_codec(codec, RtpCodecKind::Video)
-                .expect("the codec registers");
-        }
-        let registry = register_default_interceptors(Registry::new(), &mut media_engine)
-            .expect("interceptors register");
-        let peer = PeerConnectionBuilder::<std::net::SocketAddr>::new()
-            .with_media_engine(media_engine)
-            .with_interceptor_registry(registry)
-            .with_runtime(default_runtime().expect("a runtime"))
-            .with_handler(Arc::new(NoopHandler))
-            .with_udp_addrs(udp_addrs())
-            .build()
-            .await
-            .expect("an answering peer");
-        peer.set_remote_description(
-            RTCSessionDescription::offer(offer.to_owned()).expect("a valid offer"),
-        )
-        .await
-        .expect("the offer is accepted");
-        Arc::new(peer)
-    }
-
-    #[tokio::test]
-    async fn an_encoded_offer_carries_the_streams_own_profile_and_level() {
-        let (events, _events_rx) = tokio::sync::mpsc::unbounded_channel();
-        let (_peer, offer) = VideoPeer::offer(
-            TransportOptions {
-                ice_servers: Vec::new(),
-                loopback_tcp: false,
-                pace_bps: 20_000_000.0,
-            },
-            events,
-            VideoCodec::H264 {
-                profile_level_id: String::from("42c029"),
-            },
-        )
-        .await
-        .expect("a peer connection");
-        assert!(
-            offer.contains("H264/90000"),
-            "the encoded track must be offered as H.264: {offer}",
-        );
-        assert!(
-            offer.contains("packetization-mode=1;profile-level-id=42c029"),
-            "the offer must name the fed SPS's own profile-level-id: {offer}",
-        );
-        assert!(
-            !offer.contains("VP9"),
-            "an encoded source must not also offer the codec it cannot encode: {offer}",
-        );
-    }
-
     fn transport() -> TransportOptions {
         TransportOptions {
             ice_servers: Vec::new(),
@@ -1359,321 +1241,6 @@ pub(crate) mod tests {
         }
     }
 
-    /// The answer `codecs` make to a `Vp9OrH264` offer, applied to its peer.
-    pub(crate) async fn answered(codecs: Vec<RTCRtpCodecParameters>) -> (VideoPeer, String) {
-        let (events, _events_rx) = tokio::sync::mpsc::unbounded_channel();
-        let (peer, offer) = VideoPeer::offer(transport(), events, VideoCodec::Vp9OrH264)
-            .await
-            .expect("a peer connection");
-        let other = answerer_with(&offer, codecs).await;
-        let answer = other.create_answer(None).await.expect("an answer");
-        other
-            .set_local_description(answer.clone())
-            .await
-            .expect("a local description");
-        peer.accept_answer(answer.sdp.clone())
-            .await
-            .expect("the answer is accepted");
-        (peer, answer.sdp)
-    }
-
-    pub(crate) fn h264_receiver_codec() -> RTCRtpCodecParameters {
-        h264_codec(crate::h264::PROFILE_LEVEL_ID)
-    }
-
-    #[tokio::test]
-    async fn a_captured_offer_puts_vp9_first_and_h264_second() {
-        let (events, _events_rx) = tokio::sync::mpsc::unbounded_channel();
-        let (_peer, offer) = VideoPeer::offer(transport(), events, VideoCodec::Vp9OrH264)
-            .await
-            .expect("a peer connection");
-        let video = offer
-            .lines()
-            .find(|line| line.starts_with("m=video "))
-            .expect("a video section");
-        assert!(
-            video.ends_with(&format!(" {VP9_PAYLOAD_TYPE} {H264_PAYLOAD_TYPE}")),
-            "VP9 is the default a receiver with no preference answers with: {video}",
-        );
-        assert!(
-            offer.contains(&format!(
-                "a=fmtp:{H264_PAYLOAD_TYPE} level-asymmetry-allowed=1;packetization-mode=1;profile-level-id={}",
-                crate::h264::PROFILE_LEVEL_ID
-            )),
-            "H.264 is offered as the Constrained Baseline every backend emits: {offer}",
-        );
-    }
-
-    #[tokio::test]
-    async fn the_receivers_first_codec_is_the_one_sent() {
-        let (peer, answer) = answered(vec![vp9_codec(), h264_receiver_codec()]).await;
-        assert!(
-            !peer.sends_h264(),
-            "a receiver that keeps the offer's order gets VP9: {answer}"
-        );
-        let (peer, answer) = answered(vec![h264_receiver_codec()]).await;
-        assert!(peer.sends_h264(), "an H.264 receiver gets H.264: {answer}");
-        assert_eq!(
-            peer.payload_type.load(Ordering::SeqCst),
-            H264_PAYLOAD_TYPE,
-            "frames go out on the payload type the answer kept",
-        );
-    }
-
-    #[test]
-    fn an_answer_is_read_for_its_video_sections_first_known_codec() {
-        let answer = |formats: &str| {
-            format!(
-                "v=0\r\no=- 1 1 IN IP4 0.0.0.0\r\ns=-\r\nt=0 0\r\n\
-                 m=video 9 UDP/TLS/RTP/SAVPF {formats}\r\nc=IN IP4 0.0.0.0\r\n\
-                 a=rtpmap:96 rtx/90000\r\na=rtpmap:98 VP9/90000\r\na=rtpmap:102 H264/90000\r\n\
-                 m=application 9 UDP/DTLS/SCTP webrtc-datachannel\r\na=rtpmap:5 H264/90000\r\n"
-            )
-        };
-        assert!(answer_prefers_h264(&answer("102 98")));
-        assert!(answer_prefers_h264(&answer("96 102 98")), "rtx is skipped");
-        assert!(!answer_prefers_h264(&answer("98 102")));
-        assert!(!answer_prefers_h264(&answer("98")));
-        assert!(!answer_prefers_h264("v=0\r\n"), "no video, no H.264");
-    }
-
-    #[tokio::test]
-    async fn the_offer_asks_the_receiver_to_show_frames_without_playout_delay() {
-        let (events, _events_rx) = tokio::sync::mpsc::unbounded_channel();
-        let (_peer, offer) = VideoPeer::offer(
-            TransportOptions {
-                ice_servers: Vec::new(),
-                loopback_tcp: false,
-                pace_bps: 20_000_000.0,
-            },
-            events,
-            VideoCodec::Vp9,
-        )
-        .await
-        .expect("a peer connection");
-        assert!(
-            offer
-                .lines()
-                .any(|line| line.starts_with("a=extmap:") && line.ends_with(PLAYOUT_DELAY_URI)),
-            "the video must negotiate the playout-delay extension its packets carry: {offer}",
-        );
-    }
-
-    #[test]
-    fn the_profile_level_id_comes_from_the_sps_in_the_stream() {
-        // A leading zero byte, a four-byte start code and a three-byte one, so
-        // the scanner is exercised on both forms.
-        let mut stream = vec![0x00, 0x00, 0x00, 0x01];
-        stream.extend_from_slice(&[0x67, 0x42, 0xc0, 0x29, 0x8c, 0x8d]);
-        stream.extend_from_slice(&[0x00, 0x00, 0x01, 0x68, 0xce, 0x3c, 0x80]);
-        stream.extend_from_slice(&[0x00, 0x00, 0x01, 0x65, 0x88, 0x84, 0x00]);
-        assert_eq!(
-            h264_profile_level_id(&stream).as_deref(),
-            Some("42c029"),
-            "profile_idc, constraint flags and level_idc, as the SDP needs them",
-        );
-        assert_eq!(
-            h264_profile_level_id(&[0x00, 0x00, 0x01, 0x65, 0x88]),
-            None,
-            "a stream with no SPS cannot start a session",
-        );
-        let mut adjacent = vec![0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01];
-        adjacent.extend_from_slice(&[0x67, 0x42, 0xc0, 0x29]);
-        assert_eq!(
-            h264_profile_level_id(&adjacent).as_deref(),
-            Some("42c029"),
-            "an empty NAL between start codes is skipped, not fatal to the scan",
-        );
-    }
-
-    #[test]
-    fn a_fed_keyframe_is_packetized_as_parameter_sets_then_a_slice() {
-        let mut stream = vec![0x00, 0x00, 0x00, 0x01];
-        stream.extend_from_slice(&[0x67, 0x42, 0xc0, 0x29, 0x8c, 0x8d]);
-        stream.extend_from_slice(&[0x00, 0x00, 0x01, 0x68, 0xce, 0x3c, 0x80]);
-        stream.extend_from_slice(&[0x00, 0x00, 0x01, 0x65, 0x88, 0x84, 0x00]);
-        let payloader = h264_codec("42c029")
-            .rtp_codec
-            .payloader()
-            .expect("the media engine has an H.264 payloader");
-        let mut packetizer = H264Packetizer::new(payloader);
-        let packets = packetizer
-            .packetize(&stream, Instant::now(), 7, H264_PAYLOAD_TYPE)
-            .expect("a keyframe packetizes");
-        assert_eq!(
-            packets.len(),
-            2,
-            "one STAP-A for the parameter sets, one slice"
-        );
-        assert_eq!(
-            packets[0].payload[0], 0x78,
-            "the parameter sets travel as a STAP-A",
-        );
-        assert_eq!(packets[1].payload[0], 0x65, "then the IDR slice itself");
-        assert!(
-            !packets[0].header.marker && packets[1].header.marker,
-            "the marker ends the access unit, not the first fragment of it",
-        );
-        assert_eq!(
-            packets[0].header.timestamp, packets[1].header.timestamp,
-            "an access unit is one instant",
-        );
-        assert_eq!(packets[0].header.payload_type, H264_PAYLOAD_TYPE);
-    }
-
-    #[tokio::test]
-    async fn a_candidate_that_arrives_before_the_answer_is_not_refused() {
-        let (events, _events_rx) = tokio::sync::mpsc::unbounded_channel();
-        let (peer, _offer) = VideoPeer::offer(
-            TransportOptions {
-                ice_servers: Vec::new(),
-                loopback_tcp: false,
-                pace_bps: 20_000_000.0,
-            },
-            events,
-            VideoCodec::Vp9,
-        )
-        .await
-        .expect("a peer connection");
-
-        // The engine is the offerer, so the remote description only arrives with
-        // the answer; this candidate must be held, not refused.
-        peer.add_candidate(
-            String::from("candidate:1 1 udp 2113937151 192.0.2.1 40000 typ host"),
-            Some(String::from("0")),
-            Some(0),
-        )
-        .await
-        .expect("a candidate that arrives before the answer is buffered");
-    }
-
-    #[tokio::test]
-    async fn packets_ask_for_no_playout_delay_only_when_the_answer_accepts_it() {
-        for accepts in [false, true] {
-            let (events, _events_rx) = tokio::sync::mpsc::unbounded_channel();
-            let (peer, offer) = VideoPeer::offer(
-                TransportOptions {
-                    ice_servers: Vec::new(),
-                    loopback_tcp: false,
-                    pace_bps: 20_000_000.0,
-                },
-                events,
-                VideoCodec::Vp9,
-            )
-            .await
-            .expect("a peer connection");
-            // This answerer knows no playout-delay extension, so it declines it.
-            let other = answerer(&offer).await;
-            let answer = other.create_answer(None).await.expect("an answer");
-            let sdp = if accepts {
-                answer.sdp.replacen(
-                    "a=mid:0\r\n",
-                    &format!("a=mid:0\r\na=extmap:1 {PLAYOUT_DELAY_URI}\r\n"),
-                    1,
-                )
-            } else {
-                answer.sdp
-            };
-            assert_eq!(sdp.contains(PLAYOUT_DELAY_URI), accepts);
-            peer.accept_answer(sdp)
-                .await
-                .expect("the answer is accepted");
-            assert_eq!(
-                peer.playout_delay.load(Ordering::SeqCst),
-                accepts,
-                "a packet may carry the extension only when the answer accepted it",
-            );
-        }
-    }
-
-    #[tokio::test]
-    async fn held_candidates_reach_the_peer_when_the_answer_arrives() {
-        let (events, _events_rx) = tokio::sync::mpsc::unbounded_channel();
-        let (peer, offer) = VideoPeer::offer(
-            TransportOptions {
-                ice_servers: Vec::new(),
-                loopback_tcp: false,
-                pace_bps: 20_000_000.0,
-            },
-            events,
-            VideoCodec::Vp9,
-        )
-        .await
-        .expect("a peer connection");
-
-        let other = answerer(&offer).await;
-        let answer = other.create_answer(None).await.expect("an answer");
-        other
-            .set_local_description(answer.clone())
-            .await
-            .expect("a local description");
-
-        peer.add_candidate(
-            String::from("candidate:1 1 udp 2113937151 192.0.2.1 40000 typ host"),
-            Some(String::from("0")),
-            Some(0),
-        )
-        .await
-        .expect("a candidate before the answer is buffered");
-
-        let applied = peer
-            .accept_answer(answer.sdp)
-            .await
-            .expect("the answer is accepted");
-        assert_eq!(applied, 1, "the held candidate must reach the peer");
-    }
-
-    #[tokio::test]
-    async fn an_ice_restart_offers_fresh_credentials_on_the_same_peer() {
-        let (events, _events_rx) = tokio::sync::mpsc::unbounded_channel();
-        let (peer, offer) = VideoPeer::offer(
-            TransportOptions {
-                ice_servers: Vec::new(),
-                loopback_tcp: false,
-                pace_bps: 20_000_000.0,
-            },
-            events,
-            VideoCodec::Vp9,
-        )
-        .await
-        .expect("a peer connection");
-
-        let other = answerer(&offer).await;
-        let answer = other.create_answer(None).await.expect("an answer");
-        other
-            .set_local_description(answer.clone())
-            .await
-            .expect("a local description");
-        peer.accept_answer(answer.sdp)
-            .await
-            .expect("the answer is accepted");
-
-        let ufrag = |sdp: &str| {
-            sdp.lines()
-                .find_map(|line| line.strip_prefix("a=ice-ufrag:"))
-                .expect("an ICE username fragment")
-                .to_owned()
-        };
-        let restart = peer.restart_ice().await.expect("a restart offer");
-        assert!(
-            !restart.is_empty() && ufrag(&restart) != ufrag(&offer),
-            "the restart must turn over the ICE generation"
-        );
-        // The far end answers the restart as usual, on the same peer.
-        other
-            .set_remote_description(RTCSessionDescription::offer(restart).expect("a valid offer"))
-            .await
-            .expect("the restart offer applies");
-        let reanswer = other.create_answer(None).await.expect("an answer");
-        other
-            .set_local_description(reanswer.clone())
-            .await
-            .expect("a local description");
-        peer.accept_answer(reanswer.sdp)
-            .await
-            .expect("the restart answer is accepted");
-    }
-
     /// How long the restarted generation may take to nominate and reconnect,
     /// measured from the answered offer: two `check_interval` ticks. The vendored
     /// agent ticks every 200 ms (`vendor/rtc-ice/src/agent/agent_config.rs`), and

package/engine/src/portal.rs

@@ -149,78 +149,3 @@ fn choose_cursor_mode(available: BitFlags<CursorMode>) -> Result<CursorMode> {
         .find(|mode| available.contains(*mode))
         .context("cursor-unavailable: portal cannot leave the cursor out of capture")
 }
-
-#[cfg(all(test, target_os = "linux"))]
-mod tests {
-    use super::*;
-    use std::process::{Child, Command, Stdio};
-    use zbus::{connection::Builder, message::Type, MessageStream};
-
-    struct Bus(Child);
-
-    impl Drop for Bus {
-        fn drop(&mut self) {
-            let _ = self.0.kill();
-            let _ = self.0.wait();
-        }
-    }
-
-    /// A private session bus whose `org.freedesktop.portal.Desktop` owner
-    /// answers every property read the way a stale xdg-desktop-portal answers
-    /// for ScreenCast: no such interface.
-    #[tokio::test]
-    async fn open_names_the_fix_when_the_portal_exports_no_screencast() {
-        use zbus::export::futures_core::Stream;
-
-        let mut daemon = Command::new("dbus-daemon")
-            .args(["--session", "--nofork", "--print-address=1"])
-            .stdout(Stdio::piped())
-            .spawn()
-            .expect("dbus-daemon");
-        let mut address = String::new();
-        std::io::BufRead::read_line(
-            &mut std::io::BufReader::new(daemon.stdout.take().unwrap()),
-            &mut address,
-        )
-        .unwrap();
-        let _bus = Bus(daemon);
-        let address = address.trim().to_owned();
-
-        let fake = Builder::address(address.as_str())
-            .unwrap()
-            .name("org.freedesktop.portal.Desktop")
-            .unwrap()
-            .build()
-            .await
-            .unwrap();
-        let service = fake.clone();
-        let answering = tokio::spawn(async move {
-            let mut messages = MessageStream::from(&service);
-            while let Some(Ok(message)) =
-                std::future::poll_fn(|cx| std::pin::Pin::new(&mut messages).poll_next(cx)).await
-            {
-                if message.message_type() != Type::MethodCall {
-                    continue;
-                }
-                let _ = service
-                    .reply_dbus_error(
-                        &message.header(),
-                        zbus::fdo::Error::InvalidArgs(
-                            "No such interface \u{201c}org.freedesktop.portal.ScreenCast\u{201d}".into(),
-                        ),
-                    )
-                    .await;
-            }
-        });
-        // Screencast::new reads the session bus from the environment.
-        std::env::set_var("DBUS_SESSION_BUS_ADDRESS", &address);
-
-        let error = match open(None, crate::protocol::CursorMode::Embedded).await {
-            Ok(_) => panic!("a portal without ScreenCast must not open a session"),
-            Err(error) => format!("{error:#}"),
-        };
-        answering.abort();
-        assert!(error.starts_with("compositor has no ScreenCast portal"), "{error}");
-        assert!(error.contains("systemctl --user restart xdg-desktop-portal"), "{error}");
-    }
-}