fix parsing. Explicitly set simulcast fps to 30.

Author: chenosaurus

examples/local_video/src/publisher.rs

@@ -1,7 +1,7 @@
 use anyhow::Result;
 use clap::Parser;
 use livekit::e2ee::{key_provider::*, E2eeOptions, EncryptionType};
-use livekit::options::{TrackPublishOptions, VideoCodec, VideoEncoding};
+use livekit::options::{self, TrackPublishOptions, VideoCodec, VideoEncoding, VideoPreset, video as video_presets};
 use livekit::prelude::*;
 use livekit::webrtc::video_frame::{I420Buffer, VideoFrame, VideoRotation};
 use livekit::webrtc::video_source::native::NativeVideoSource;
@@ -146,6 +146,7 @@ async fn run(args: Args, ctrl_c_received: Arc<AtomicBool>) -> Result<()> {
     info!("Connecting to LiveKit room '{}' as '{}'...", args.room_name, args.identity);
     let mut room_options = RoomOptions::default();
     room_options.auto_subscribe = true;
+    room_options.dynacast = true;
 
     // Configure E2EE if an encryption key is provided
     if let Some(ref e2ee_key) = args.e2ee_key {
@@ -220,19 +221,40 @@ async fn run(args: Args, ctrl_c_received: Arc<AtomicBool>) -> Result<()> {
     let requested_codec = if args.h265 { VideoCodec::H265 } else { VideoCodec::H264 };
     info!("Attempting publish with codec: {}", requested_codec.as_str());
 
+    // Compute an explicit video encoding so all simulcast layers use 30 fps.
+    // The SDK defaults reduce lower layers to 15/20 fps; we override that here.
+    let target_fps = args.fps as f64;
+    let main_encoding = {
+        let base = options::compute_appropriate_encoding(false, width, height, VideoCodec::H264);
+        VideoEncoding {
+            max_bitrate: args.max_bitrate.unwrap_or(base.max_bitrate),
+            max_framerate: target_fps,
+        }
+    };
+    let simulcast_presets = compute_simulcast_presets_30fps(width, height, target_fps);
+    info!(
+        "Video encoding: {}x{} @ {:.0} fps, {} bps (simulcast layers: {})",
+        width,
+        height,
+        target_fps,
+        main_encoding.max_bitrate,
+        simulcast_presets
+            .iter()
+            .map(|p| format!("{}x{}@{:.0}fps/{}bps", p.width, p.height, p.encoding.max_framerate, p.encoding.max_bitrate))
+            .collect::<Vec<_>>()
+            .join(", "),
+    );
+
     let publish_opts = |codec: VideoCodec| {
-        let mut opts = TrackPublishOptions {
+        TrackPublishOptions {
             source: TrackSource::Camera,
             simulcast: args.simulcast,
             video_codec: codec,
             user_timestamp: args.attach_timestamp,
+            video_encoding: Some(main_encoding.clone()),
+            simulcast_layers: Some(simulcast_presets.clone()),
             ..Default::default()
-        };
-        if let Some(bitrate) = args.max_bitrate {
-            opts.video_encoding =
-                Some(VideoEncoding { max_bitrate: bitrate, max_framerate: args.fps as f64 });
         }
-        opts
     };
 
     let publish_result = room
@@ -486,3 +508,19 @@ async fn run(args: Args, ctrl_c_received: Arc<AtomicBool>) -> Result<()> {
 
     Ok(())
 }
+
+/// Build simulcast presets that match the SDK defaults but with a uniform frame rate.
+/// The SDK's built-in `DEFAULT_SIMULCAST_PRESETS` use 15/20 fps for lower layers;
+/// this keeps the same resolutions and bitrates but overrides fps to `target_fps`.
+fn compute_simulcast_presets_30fps(width: u32, height: u32, target_fps: f64) -> Vec<VideoPreset> {
+    let ar = width as f32 / height as f32;
+    let defaults: &[VideoPreset] = if f32::abs(ar - 16.0 / 9.0) < f32::abs(ar - 4.0 / 3.0) {
+        video_presets::DEFAULT_SIMULCAST_PRESETS
+    } else {
+        livekit::options::video43::DEFAULT_SIMULCAST_PRESETS
+    };
+    defaults
+        .iter()
+        .map(|p| VideoPreset::new(p.width, p.height, p.encoding.max_bitrate, target_fps))
+        .collect()
+}

examples/local_video/src/subscriber.rs

@@ -334,6 +334,26 @@ async fn handle_track_subscribed(
             std::mem::swap(&mut s.u, &mut u_buf);
             std::mem::swap(&mut s.v, &mut v_buf);
             s.dirty = true;
+
+            if let Some(ts) = frame.user_timestamp_us {
+                let now_us = current_timestamp_us();
+                let delta_ms = (now_us - ts) as f64 / 1000.0;
+                if ts < 0 || ts > 2_000_000_000_000_000 || delta_ms < -60_000.0 {
+                    log::warn!(
+                        "[Subscriber] BAD TIMESTAMP: frame_id={:?} user_ts={} \
+                         timestamp_us={} now_us={} delta_ms={:.1} \
+                         prev_user_ts={:?} prev_frame_id={:?}",
+                        frame.frame_id,
+                        ts,
+                        frame.timestamp_us,
+                        now_us,
+                        delta_ms,
+                        s.user_timestamp_us,
+                        s.frame_id,
+                    );
+                }
+            }
+
             s.user_timestamp_us = frame.user_timestamp_us;
             s.frame_id = frame.frame_id;
 
@@ -674,6 +694,8 @@ async fn run(args: Args, ctrl_c_received: Arc<AtomicBool>) -> Result<()> {
     info!("Connecting to LiveKit room '{}' as '{}'...", args.room_name, args.identity);
     let mut room_options = RoomOptions::default();
     room_options.auto_subscribe = true;
+    room_options.dynacast = true;
+    room_options.adaptive_stream = true;
 
     // Configure E2EE if an encryption key is provided
     if let Some(ref e2ee_key) = args.e2ee_key {

libwebrtc/src/native/user_timestamp.rs

@@ -66,6 +66,12 @@ impl UserTimestampHandler {
         let ts = self.sys_handle.lookup_user_timestamp(rtp_timestamp);
         if ts >= 0 {
             let frame_id = self.sys_handle.last_lookup_frame_id();
+            if ts > 2_000_000_000_000_000 || ts < 0 {
+                log::warn!(
+                    "[UserTS-FFI] C++ returned bad ts={} (0x{:016x}) fid={} rtp_ts={}",
+                    ts, ts, frame_id, rtp_timestamp
+                );
+            }
             Some((ts, frame_id))
         } else {
             None

libwebrtc/src/native/video_stream.rs

@@ -113,7 +113,15 @@ impl sys_vt::VideoSink for VideoTrackObserver {
             .and_then(|h| h.lookup_frame_metadata(rtp_timestamp));
 
         let (user_timestamp_us, frame_id) = match meta {
-            Some((ts, fid)) => (Some(ts), Some(fid)),
+            Some((ts, fid)) => {
+                if ts < 0 || ts > 2_000_000_000_000_000 {
+                    log::warn!(
+                        "[on_frame] SUSPICIOUS user_ts={} fid={} rtp_ts={}",
+                        ts, fid, rtp_timestamp
+                    );
+                }
+                (Some(ts), Some(fid))
+            }
             None => (None, None),
         };
 

livekit-ffi/src/conversion/room.rs

@@ -253,6 +253,7 @@ impl From<proto::TrackPublishOptions> for TrackPublishOptions {
             red: opts.red.unwrap_or(default_publish_options.red),
             simulcast: opts.simulcast.unwrap_or(default_publish_options.simulcast),
             stream: opts.stream.unwrap_or(default_publish_options.stream),
+            simulcast_layers: default_publish_options.simulcast_layers,
             preconnect_buffer: opts
                 .preconnect_buffer
                 .unwrap_or(default_publish_options.preconnect_buffer),

livekit/src/room/options.rs

@@ -84,6 +84,9 @@ pub struct TrackPublishOptions {
     pub dtx: bool,
     pub red: bool,
     pub simulcast: bool,
+    /// Custom simulcast layer presets (low, mid). When set, these override the
+    /// SDK's built-in defaults which reduce fps on lower layers.
+    pub simulcast_layers: Option<Vec<VideoPreset>>,
     // pub name: String,
     pub source: TrackSource,
     pub stream: String,
@@ -100,6 +103,7 @@ impl Default for TrackPublishOptions {
             dtx: true,
             red: true,
             simulcast: true,
+            simulcast_layers: None,
             source: TrackSource::Unknown,
             stream: "".to_string(),
             preconnect_buffer: false,
@@ -149,7 +153,10 @@ pub fn compute_video_encodings(
         return into_rtp_encodings(width, height, &[initial_preset]);
     }
 
-    let mut simulcast_presets = compute_default_simulcast_presets(screenshare, &initial_preset);
+    let mut simulcast_presets = match options.simulcast_layers {
+        Some(ref custom) => custom.clone(),
+        None => compute_default_simulcast_presets(screenshare, &initial_preset),
+    };
 
     let mid_preset = simulcast_presets.pop();
     let low_preset = simulcast_presets.pop();

webrtc-sys/include/livekit/user_timestamp.h

@@ -53,6 +53,7 @@ constexpr size_t kUserTimestampTrailerSize =
 struct FrameMetadata {
   int64_t user_timestamp_us;
   uint32_t frame_id;
+  uint32_t ssrc;  // SSRC that produced this entry (for simulcast tracking)
 };
 
 /// Frame transformer that appends/extracts user timestamp trailers.
@@ -132,13 +133,38 @@ class UserTimestampTransformer : public webrtc::FrameTransformerInterface {
   mutable std::deque<int64_t> send_map_order_;
   static constexpr size_t kMaxSendMapEntries = 300;
 
+  // Send-side per-SSRC stats for diagnosing simulcast encoding delay.
+  struct SendSsrcStats {
+    uint64_t frame_count{0};
+    int64_t last_user_ts{0};
+    int64_t sum_encode_delay_us{0};
+    uint64_t encode_delay_samples{0};
+  };
+  mutable std::unordered_map<uint32_t, SendSsrcStats> send_ssrc_stats_;
+
   // Receive-side map: RTP timestamp -> frame metadata.
   // Keyed by RTP timestamp so decoded frames can look up their
   // metadata regardless of frame drops or reordering.
   mutable webrtc::Mutex recv_map_mutex_;
   mutable std::unordered_map<uint32_t, FrameMetadata> recv_map_;
   mutable std::deque<uint32_t> recv_map_order_;
   static constexpr size_t kMaxRecvMapEntries = 300;
+
+  // Simulcast tracking: detect layer switches and flush stale entries.
+  mutable uint32_t recv_active_ssrc_{0};
+  mutable int64_t recv_last_user_ts_{0};
+  mutable uint64_t recv_frame_count_{0};
+  mutable uint64_t recv_lookup_hits_{0};
+  mutable uint64_t recv_lookup_misses_{0};
+
+  // Receive-side per-SSRC latency tracking.
+  struct RecvSsrcStats {
+    uint64_t frame_count{0};
+    int64_t sum_latency_us{0};
+    uint64_t latency_samples{0};
+    int64_t max_latency_us{0};
+  };
+  mutable std::unordered_map<uint32_t, RecvSsrcStats> recv_ssrc_stats_;
 };
 
 /// Wrapper class for Rust FFI that manages user timestamp transformers.