fix x-google-start-bitrate for vp8 and other codex and make it adaptive to network

.changeset/simplify-start-bitrate-and-degradation-defaults.md

@@ -0,0 +1,12 @@
+---
+"livekit": patch
+---
+
+Simplify x-google-start-bitrate logic and update degradation preference defaults
+
+- Start bitrate: use min(90% of target, 1 Mbps) instead of adaptive network hints
+- Remove slow connection detection and network quality hints on reconnect
+- Default degradation preference by track source:
+  - Camera: MaintainFramerate (smoother video)
+  - Screenshare: MaintainResolution (clarity for text/UI)
+  - Other: Balanced

livekit-api/src/signal_client/signal_stream.rs

@@ -20,7 +20,7 @@
 use livekit_protocol as proto;
 use livekit_runtime::{JoinHandle, TcpStream};
 use prost::Message as ProtoMessage;
 use std::{env, io, time::Duration};
 
 use tokio::sync::{mpsc, oneshot};
 
@@ -157,7 +157,7 @@
                     let mut proxy_auth_header = None;
                     if let Some(password) = proxy_url.password() {
                         let auth = format!("{}:{}", proxy_url.username(), password);
                         let auth = format!("Basic {}", base64::encode(auth));
                         proxy_auth_header = Some(auth);
                     }
 
@@ -407,7 +407,22 @@
                 }
                 Ok(Message::Frame(_)) => {}
                 Err(WsError::Protocol(ProtocolError::ResetWithoutClosingHandshake)) => {
-                    break; // Ignore
+                    log::debug!("websocket reset without closing handshake");
+                    break; // Treat as normal close
+                }
+                Err(WsError::Io(ref io_err))
+                    if io_err.kind() == std::io::ErrorKind::UnexpectedEof =>
+                {
+                    // TLS connection closed without close_notify - treat as normal close
+                    // This happens when the server closes the connection abruptly
+                    log::debug!(
+                        "websocket closed with unexpected EOF (TLS close without close_notify)"
+                    );
+                    break;
+                }
+                Err(WsError::ConnectionClosed) | Err(WsError::AlreadyClosed) => {
+                    log::debug!("websocket connection already closed");
+                    break;
                 }
                 _ => {
                     log::error!("unhandled websocket message {:?}", msg);

livekit/src/room/options.rs

@@ -142,12 +142,14 @@ pub struct TrackPublishOptions {
     /// Controls how the encoder trades off between resolution and framerate
     /// when bandwidth is constrained.
     ///
-    /// - `MaintainResolution`: Prioritizes resolution, drops frames if needed
     /// - `MaintainFramerate`: Prioritizes framerate, reduces resolution if needed
+    /// - `MaintainResolution`: Prioritizes resolution, drops frames if needed
     /// - `Balanced`: Balances between both
     ///
-    /// If not set, the SDK will use a smart default based on the track source
-    /// and resolution (MaintainResolution for screenshare or video >= 540p).
+    /// If not set, the SDK uses defaults based on track source:
+    /// - Camera: `MaintainFramerate` (smoother video for real-time communication)
+    /// - Screen share: `MaintainResolution` (clarity is critical for text/UI)
+    /// - Other/unknown: `Balanced`
     pub degradation_preference: Option<DegradationPreference>,
 }
 
@@ -175,14 +177,10 @@ impl Default for TrackPublishOptions {
 /// Returns the appropriate degradation preference for a video track.
 ///
 /// If the user explicitly set a preference in `TrackPublishOptions`, that is returned.
-/// Otherwise, defaults to `MaintainResolution` for all video tracks.
-///
-/// `MaintainResolution` ensures video clarity is preserved during bandwidth constraints
-/// by dropping frames rather than reducing resolution. This prevents the "blurry video"
-/// issue that users commonly report during initial connection or network fluctuations.
-///
-/// Users who prefer smoother video over clarity can explicitly set `Balanced` or
-/// `MaintainFramerate` in their `TrackPublishOptions`.
+/// Otherwise, defaults based on track source:
+/// - `MaintainFramerate` for camera tracks (smoother video for real-time communication)
+/// - `MaintainResolution` for screen share (clarity is critical for reading text/UI)
+/// - `Balanced` for other/unknown sources
 pub fn get_default_degradation_preference(
     options: &TrackPublishOptions,
     _height: u32,
@@ -192,9 +190,12 @@ pub fn get_default_degradation_preference(
         return pref;
     }
 
-    // Default to MaintainResolution for all video tracks to prevent blurry video
-    // during bandwidth ramp-up or network constraints
-    DegradationPreference::MaintainResolution
+    // Default based on track source
+    match options.source {
+        TrackSource::Camera => DegradationPreference::MaintainFramerate,
+        TrackSource::Screenshare => DegradationPreference::MaintainResolution,
+        _ => DegradationPreference::Balanced,
+    }
 }
 
 impl VideoPreset {
@@ -571,29 +572,28 @@ mod tests {
     }
 
     #[test]
-    fn degradation_preference_defaults_to_maintain_resolution() {
-        // All sources should default to MaintainResolution
+    fn degradation_preference_defaults_by_source() {
+        // Camera defaults to MaintainFramerate (smoother video)
         let camera_options =
             TrackPublishOptions { source: TrackSource::Camera, ..Default::default() };
-        let screenshare_options =
-            TrackPublishOptions { source: TrackSource::Screenshare, ..Default::default() };
-        let default_options = TrackPublishOptions::default();
-
         assert_eq!(
             get_default_degradation_preference(&camera_options, 1080),
-            DegradationPreference::MaintainResolution
+            DegradationPreference::MaintainFramerate
         );
+
+        // Screenshare defaults to MaintainResolution (clarity for text/UI)
+        let screenshare_options =
+            TrackPublishOptions { source: TrackSource::Screenshare, ..Default::default() };
         assert_eq!(
             get_default_degradation_preference(&screenshare_options, 1080),
             DegradationPreference::MaintainResolution
         );
+
+        // Unknown/default source defaults to Balanced
+        let default_options = TrackPublishOptions::default();
         assert_eq!(
             get_default_degradation_preference(&default_options, 720),
-            DegradationPreference::MaintainResolution
-        );
-        assert_eq!(
-            get_default_degradation_preference(&default_options, 360),
-            DegradationPreference::MaintainResolution
+            DegradationPreference::Balanced
         );
     }