@desklink/host 0.2.0 → 0.3.0

package/engine/src/peer.rs

@@ -1,4 +1,4 @@
-//! The WebRTC handoff: one VP9 video track out, one control data channel in.
+//! The WebRTC handoff: one video track out, one control data channel in.
 //!
 //! The engine is the offerer. The consumer's own authenticated channel carries
 //! the SDP and ICE candidates to the client and brings the answer back; this
@@ -12,7 +12,8 @@
 
 use anyhow::{Context, Result};
 use rtc::interceptor::{
-    Attribute, Interceptor, PacerBuilder, Packet, Registry, Slot, StreamInfo, TaggedPacket,
+    Attribute, BandwidthEstimator, CongestionControlBuilder, Interceptor, PacerBuilder, Packet,
+    PacketReport, Registry, Slot, StreamInfo, TaggedPacket, TwccSenderBuilder,
 };
 use rtc::media_stream::MediaStreamTrack;
 use rtc::peer_connection::configuration::interceptor_registry::register_default_interceptors;
@@ -26,9 +27,11 @@ use rtc::peer_connection::transport::{RTCIceCandidateInit, RTCIceServer};
 use rtc::rtcp::payload_feedbacks::full_intra_request::FullIntraRequest;
 use rtc::rtcp::payload_feedbacks::picture_loss_indication::PictureLossIndication;
 use rtc::rtcp::receiver_report::ReceiverReport;
+use rtc::rtp::extension::playout_delay_extension::PlayoutDelayExtension;
+use rtc::rtp::extension::HeaderExtension;
 use rtc::rtp_transceiver::rtp_sender::{
     RTCPFeedback, RTCRtpCodec, RTCRtpCodecParameters, RTCRtpCodingParameters,
-    RTCRtpEncodingParameters, RtpCodecKind,
+    RTCRtpEncodingParameters, RTCRtpHeaderExtensionCapability, RtpCodecKind,
 };
 use rtc::rtp_transceiver::PayloadType;
 use rtc::sansio::Protocol;
@@ -62,6 +65,10 @@ pub const H264_PAYLOAD_TYPE: PayloadType = 102;
 pub enum VideoCodec {
     /// VP9 in flexible mode, encoded by this engine from captured frames.
     Vp9,
+    /// Captured frames again, offered as VP9 first and H.264 second: the
+    /// receiver's answer picks, so one that states no preference keeps VP9,
+    /// and one whose platform decodes only H.264 in hardware can ask for it.
+    Vp9OrH264,
     /// H.264 the consumer encoded and feeds. The profile-level-id is read from
     /// the fed stream's own SPS, so a receiver's decoder is configured for the
     /// profile actually arriving rather than for one the engine guessed.
@@ -84,8 +91,8 @@ fn vp9_codec() -> RTCRtpCodecParameters {
 
 /// H.264 with `packetization-mode=1`, which is what the device helpers emit and
 /// what every WebRTC receiver implements. Key frame requests are negotiated so
-/// the receiver has a defined way to ask; the engine turns one into a
-/// `session.keyframeRequest` for the consumer that owns the encoder.
+/// the receiver has a defined way to ask; for a fed stream the engine turns one
+/// into a `session.keyframeRequest` for the consumer that owns the encoder.
 fn h264_codec(profile_level_id: &str) -> RTCRtpCodecParameters {
     RTCRtpCodecParameters {
         rtp_codec: RTCRtpCodec {
@@ -126,6 +133,38 @@ pub fn h264_profile_level_id(annex_b: &[u8]) -> Option<String> {
     None
 }
 
+/// Whether an answer puts H.264 ahead of VP9 on its video section: the
+/// receiver's preference, which the codec it is sent follows.
+fn answer_prefers_h264(sdp: &str) -> bool {
+    let Some(video) = sdp
+        .split("\nm=")
+        .find(|section| section.trim_start_matches("m=").starts_with("video "))
+    else {
+        return false;
+    };
+    let mut lines = video.lines();
+    let formats: Vec<&str> = lines
+        .next()
+        .map(|line| line.split_whitespace().skip(3).collect())
+        .unwrap_or_default();
+    let names: Vec<(&str, &str)> = lines
+        .filter_map(|line| line.trim_end().strip_prefix("a=rtpmap:"))
+        .filter_map(|map| map.split_once(' '))
+        .collect();
+    formats
+        .iter()
+        .find_map(|format| {
+            let (_, name) = names.iter().find(|(pt, _)| pt == format)?;
+            let name = name.split('/').next()?.to_ascii_uppercase();
+            match name.as_str() {
+                "H264" => Some(true),
+                "VP9" => Some(false),
+                _ => None,
+            }
+        })
+        .unwrap_or(false)
+}
+
 /// NAL type 7: sequence parameter set.
 const SPS_NAL_TYPE: u8 = 7;
 
@@ -207,6 +246,118 @@ pub struct TransportOptions {
 /// a loop that never shows a sharp picture.
 const PACE_BURST_BITS: f64 = 256_000.0;
 
+/// The receiver's playout delay, stated on every video packet: none. A
+/// remote desktop answers the hand that is driving it, so a frame should be
+/// shown when it is decoded rather than held in a jitter buffer to smooth
+/// playback; a browser otherwise adds about 10 ms of buffering and paces
+/// presentation to its own cadence, costing both latency and frames.
+const PLAYOUT_DELAY_URI: &str = "http://www.webrtc.org/experiments/rtp-hdrext/playout-delay";
+const NO_PLAYOUT_DELAY: HeaderExtension = HeaderExtension::PlayoutDelay(PlayoutDelayExtension {
+    min_delay: 0,
+    max_delay: 0,
+});
+/// What the far end's transport-wide feedback says about the path.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct PathReport {
+    /// The queueing delay no packet escaped over the last `STANDING_WINDOW`:
+    /// the lowest one-way delay in it above the lowest the path has shown. A
+    /// burst that one frame queues up lifts some packets, not all of them; a
+    /// link carrying more than it can drain lifts every one.
+    pub queue_delay: Duration,
+    /// What arrived over the last `DELIVERED_WINDOW`, in kbps.
+    pub delivered_kbps: u32,
+}
+
+/// How long the lowest one-way delay is remembered: a path's base delay is the
+/// lowest of the last one to two of these, so a queue that stands for a while
+/// is still measured against the empty path, and a route change is learnt.
+const FLOOR_WINDOW: Duration = Duration::from_secs(15);
+const STANDING_WINDOW: Duration = Duration::from_millis(200);
+const DELIVERED_WINDOW: Duration = Duration::from_millis(500);
+
+/// Reads the queueing delay out of transport-wide congestion feedback (every
+/// packet's departure here against its arrival there) for the session's rate
+/// control to act on. The rate decision stays in the session, beside the
+/// encoder it drives; this only measures. Its own "target" is the constant
+/// pacing rate, so the pacer is never retargeted from here.
+struct QueueDelay {
+    report: Arc<Mutex<Option<PathReport>>>,
+    pace_bps: f64,
+    epoch: Option<Instant>,
+    /// The lowest one-way delay in the previous and the current window, in µs
+    /// on an arbitrary offset (the two clocks are not synchronized).
+    floor: [i64; 2],
+    floor_since: Option<Instant>,
+    /// Recent arrivals: arrival and one-way delay in µs, size in bytes.
+    recent: VecDeque<(i64, i64, usize)>,
+}
+
+impl QueueDelay {
+    fn new(report: Arc<Mutex<Option<PathReport>>>, pace_bps: f64) -> Self {
+        Self {
+            report,
+            pace_bps,
+            epoch: None,
+            floor: [i64::MAX; 2],
+            floor_since: None,
+            recent: VecDeque::new(),
+        }
+    }
+}
+
+impl BandwidthEstimator for QueueDelay {
+    fn on_reports(&mut self, now: Instant, reports: &[PacketReport]) {
+        let Some(first) = reports.first() else {
+            return;
+        };
+        let epoch = *self.epoch.get_or_insert(first.departure);
+        let before = self.recent.len();
+        for report in reports {
+            let Some(arrival) = report.arrival.filter(|_| report.arrived) else {
+                continue;
+            };
+            let arrival = arrival.as_micros() as i64;
+            let delay = arrival
+                - report
+                    .departure
+                    .saturating_duration_since(epoch)
+                    .as_micros() as i64;
+            self.floor[1] = self.floor[1].min(delay);
+            self.recent.push_back((arrival, delay, report.size));
+        }
+        let since = *self.floor_since.get_or_insert(now);
+        if now.saturating_duration_since(since) >= FLOOR_WINDOW {
+            self.floor = [self.floor[1], i64::MAX];
+            self.floor_since = Some(now);
+        }
+        if self.recent.len() == before {
+            return;
+        }
+        let latest = self.recent.iter().map(|(at, _, _)| *at).max().unwrap_or(0);
+        let delivered_since = latest - DELIVERED_WINDOW.as_micros() as i64;
+        self.recent.retain(|(at, _, _)| *at >= delivered_since);
+        let standing_since = latest - STANDING_WINDOW.as_micros() as i64;
+        let standing = self
+            .recent
+            .iter()
+            .filter(|(at, _, _)| *at >= standing_since)
+            .map(|(_, delay, _)| *delay)
+            .min()
+            .unwrap_or(0);
+        let base = self.floor[0].min(self.floor[1]);
+        let bytes: usize = self.recent.iter().map(|(_, _, size)| size).sum();
+        *lock(&self.report) = Some(PathReport {
+            queue_delay: Duration::from_micros(standing.saturating_sub(base).max(0) as u64),
+            delivered_kbps: (bytes as u64 * 8 * 1000 / DELIVERED_WINDOW.as_micros() as u64)
+                .min(u32::MAX as u64) as u32,
+        });
+    }
+
+    fn target_bitrate(&self) -> f64 {
+        self.pace_bps
+    }
+}
+
 struct Handler {
     events: tokio::sync::mpsc::UnboundedSender<PeerEvent>,
     wants_keyframe: Arc<AtomicBool>,
@@ -597,13 +748,25 @@ pub struct VideoPeer {
     wants_keyframe: Arc<AtomicBool>,
     /// True while the transport is connected: frames sent before it are lost.
     connected: Arc<AtomicBool>,
+    /// True when the answer accepted the playout-delay extension. A packet
+    /// carrying an extension the answer declined is dropped whole by the
+    /// sender, so a receiver that declines it would get no picture at all.
+    playout_delay: AtomicBool,
     track: Arc<TrackLocalStaticRTP>,
     packetizer: Mutex<Packetizer>,
     ssrc: u32,
     control: Arc<dyn DataChannel>,
-    payload_type: PayloadType,
+    /// The payload type frames go out on; H.264's once an answer to a
+    /// `Vp9OrH264` offer prefers it.
+    payload_type: std::sync::atomic::AtomicU8,
+    /// Offered H.264 beside VP9, for the answer to pick.
+    offers_h264: bool,
+    /// The answer picked H.264: the encoder has to follow.
+    sends_h264: AtomicBool,
     /// Loss fractions (RFC 3550, /256) the far end reported, oldest first.
     loss: Arc<Mutex<Vec<u8>>>,
+    /// The latest queueing delay transport-wide feedback showed, if any.
+    path: Arc<Mutex<Option<PathReport>>>,
     feedback: tokio::task::JoinHandle<()>,
     /// The engine is the offerer, so a candidate can arrive before the answer
     /// that supplies its remote description; those are held here until it does.
@@ -627,13 +790,29 @@ impl VideoPeer {
         let runtime = default_runtime().context("no WebRTC runtime is enabled")?;
 
         let mut media_engine = MediaEngine::default();
-        let video_codec = match &codec {
-            VideoCodec::Vp9 => vp9_codec(),
-            VideoCodec::H264 { profile_level_id } => h264_codec(profile_level_id),
+        // In preference order: the offer lists them so, and a receiver that
+        // states no preference of its own answers with the first.
+        let video_codecs = match &codec {
+            VideoCodec::Vp9 => vec![vp9_codec()],
+            VideoCodec::Vp9OrH264 => vec![vp9_codec(), h264_codec(crate::h264::PROFILE_LEVEL_ID)],
+            VideoCodec::H264 { profile_level_id } => vec![h264_codec(profile_level_id)],
         };
+        let video_codec = video_codecs[0].clone();
+        for offered in &video_codecs {
+            media_engine
+                .register_codec(offered.clone(), RtpCodecKind::Video)
+                .with_context(|| format!("failed to offer {codec:?}"))?;
+        }
         media_engine
-            .register_codec(video_codec.clone(), RtpCodecKind::Video)
-            .with_context(|| format!("failed to offer {codec:?}"))?;
+            .register_header_extension(
+                RTCRtpHeaderExtensionCapability {
+                    uri: String::from(PLAYOUT_DELAY_URI),
+                },
+                RtpCodecKind::Video,
+                None,
+            )
+            .context("failed to offer the playout-delay extension")?;
+        let path = Arc::new(Mutex::new(None));
         let registry = register_default_interceptors(Registry::new(), &mut media_engine)?
             .with(
                 Slot::Pacer,
@@ -642,6 +821,14 @@ impl VideoPeer {
                     .with_burst_bits(PACE_BURST_BITS)
                     .build(),
             )
+            // Number every packet transport-wide, so the receiver reports when
+            // each one arrived, and read those reports for the queueing delay.
+            .with(Slot::TwccSender, TwccSenderBuilder::new().build())
+            .with(
+                Slot::CongestionControl,
+                CongestionControlBuilder::new(QueueDelay::new(path.clone(), options.pace_bps))
+                    .build(),
+            )
             // Last, so every interceptor has seen the whole of the inbound RTCP.
             .with(Slot::from(14_000), FeedbackForwarder::default());
 
@@ -697,14 +884,19 @@ impl VideoPeer {
                 String::from("desktop"),
                 String::from("desktop"),
                 RtpCodecKind::Video,
-                vec![RTCRtpEncodingParameters {
-                    rtp_coding_parameters: RTCRtpCodingParameters {
-                        ssrc: Some(ssrc),
+                // One encoding per offered codec is how a track states its
+                // codec preferences; one stream is sent, on the first.
+                video_codecs
+                    .iter()
+                    .map(|offered| RTCRtpEncodingParameters {
+                        rtp_coding_parameters: RTCRtpCodingParameters {
+                            ssrc: Some(ssrc),
+                            ..Default::default()
+                        },
+                        codec: offered.rtp_codec.clone(),
                         ..Default::default()
-                    },
-                    codec: video_codec.rtp_codec.clone(),
-                    ..Default::default()
-                }],
+                    })
+                    .collect(),
             )));
         let sender = peer
             .add_track(Arc::clone(&track) as Arc<dyn TrackLocal>)
@@ -735,7 +927,7 @@ impl VideoPeer {
         ));
 
         let packetizer = match &codec {
-            VideoCodec::Vp9 => Packetizer::Vp9(Vp9Packetizer::new()),
+            VideoCodec::Vp9 | VideoCodec::Vp9OrH264 => Packetizer::Vp9(Vp9Packetizer::new()),
             VideoCodec::H264 { .. } => Packetizer::H264(H264Packetizer::new(
                 video_codec
                     .rtp_codec
@@ -752,12 +944,16 @@ impl VideoPeer {
                 peer,
                 wants_keyframe,
                 connected,
+                playout_delay: AtomicBool::new(false),
                 track,
                 packetizer: Mutex::new(packetizer),
                 ssrc,
                 control,
-                payload_type,
+                payload_type: std::sync::atomic::AtomicU8::new(payload_type),
+                offers_h264: codec == VideoCodec::Vp9OrH264,
+                sends_h264: AtomicBool::new(false),
                 loss,
+                path,
                 feedback,
                 candidates: Mutex::new(PendingCandidates::default()),
             },
@@ -767,15 +963,40 @@ impl VideoPeer {
 
     pub async fn accept_answer(&self, sdp: String) -> Result<usize> {
         let answer = RTCSessionDescription::answer(sdp).context("the answer is not valid SDP")?;
+        let prefers_h264 = self.offers_h264 && answer_prefers_h264(&answer.sdp);
         self.peer
             .set_remote_description(answer)
             .await
             .context("the peer refused the answer")?;
-        let held = {
+        // What the sender negotiated is what it checks each packet against.
+        let mut playout_delay = false;
+        for sender in self.peer.get_senders().await {
+            if let Ok(parameters) = sender.get_parameters().await {
+                playout_delay |= parameters
+                    .rtp_parameters
+                    .header_extensions
+                    .iter()
+                    .any(|extension| extension.uri == PLAYOUT_DELAY_URI);
+            }
+        }
+        self.playout_delay.store(playout_delay, Ordering::SeqCst);
+        let (first, held) = {
             let mut state = lock(&self.candidates);
+            let first = !state.ready;
             state.ready = true;
-            std::mem::take(&mut state.held)
+            (first, std::mem::take(&mut state.held))
         };
+        // The first answer picks the codec, before any frame has gone out; an
+        // ICE restart's answer comes from the same receiver and keeps it.
+        if first && prefers_h264 {
+            let payloader = h264_codec(crate::h264::PROFILE_LEVEL_ID)
+                .rtp_codec
+                .payloader()
+                .context("the media engine has no H.264 payloader")?;
+            *lock(&self.packetizer) = Packetizer::H264(H264Packetizer::new(payloader));
+            self.payload_type.store(H264_PAYLOAD_TYPE, Ordering::SeqCst);
+            self.sends_h264.store(true, Ordering::SeqCst);
+        }
         let mut applied = 0;
         for candidate in held {
             // Each was acknowledged when it arrived; a bad one must not turn the
@@ -833,6 +1054,11 @@ impl VideoPeer {
             .context("the peer refused an ICE candidate")
     }
 
+    /// Whether the answer asked for H.264 rather than VP9.
+    pub fn sends_h264(&self) -> bool {
+        self.sends_h264.load(Ordering::SeqCst)
+    }
+
     /// Whether the transport is connected; a frame sent before it is lost.
     pub fn is_connected(&self) -> bool {
         self.connected.load(Ordering::SeqCst)
@@ -853,11 +1079,16 @@ impl VideoPeer {
             keyframe,
             captured,
             self.ssrc,
-            self.payload_type,
+            self.payload_type.load(Ordering::SeqCst),
         )?;
+        let extensions: &[HeaderExtension] = if self.playout_delay.load(Ordering::SeqCst) {
+            &[NO_PLAYOUT_DELAY]
+        } else {
+            &[]
+        };
         for packet in packets {
             self.track
-                .write_rtp_with_extensions(packet, &[])
+                .write_rtp_with_extensions(packet, extensions)
                 .await
                 .context("failed to hand a packet to the track")?;
         }
@@ -869,6 +1100,12 @@ impl VideoPeer {
         std::mem::take(&mut *lock(&self.loss))
     }
 
+    /// Take the path report that arrived since the last call, if any; `None`
+    /// also when the receiver sends no transport-wide feedback.
+    pub fn take_path_report(&self) -> Option<PathReport> {
+        lock(&self.path).take()
+    }
+
     /// 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)
@@ -902,18 +1139,72 @@ fn lock<T>(mutex: &Mutex<T>) -> std::sync::MutexGuard<'_, T> {
 }
 
 #[cfg(test)]
-mod tests {
+pub(crate) mod tests {
     use super::*;
 
+    #[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();
-        media_engine
-            .register_codec(vp9_codec(), RtpCodecKind::Video)
-            .expect("VP9 registers");
+        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()
@@ -963,6 +1254,114 @@ mod tests {
         );
     }
 
+    fn transport() -> TransportOptions {
+        TransportOptions {
+            ice_servers: Vec::new(),
+            loopback_tcp: false,
+            pace_bps: 20_000_000.0,
+        }
+    }
+
+    /// 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
@@ -1051,6 +1450,45 @@ mod tests {
         .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();