wip

Author: peaBerberian

src/rs-core/adaptive/mod.rs

@@ -17,6 +17,7 @@ const BOLA_MIN_LOW_BUFFER: f64 = 3.0;
 const BOLA_MAX_LOW_BUFFER: f64 = 10.0;
 const ABANDON_MIN_PROGRESS_DURATION_MS: f64 = 500.0;
 const ABANDON_MIN_PROGRESS_SAMPLES: u32 = 3;
+const ABANDON_MIN_REPLACEMENT_GAIN_S: f64 = 0.25;
 
 impl AdaptiveQualitySelector {
     /// Creates new `AdaptiveQualitySelector`.
@@ -113,11 +114,24 @@ impl AdaptiveQualitySelector {
         pending_bytes_total: Option<u32>,
         progress_duration_ms: f64,
         progress_samples: u32,
-        buffer_level: f64,
+        playback_rate: f64,
+        segment_duration: Option<f64>,
+        buffer_starvation_delay: f64,
     ) -> bool {
+        if !playback_rate.is_finite() || playback_rate <= 0. || buffer_starvation_delay <= 0. {
+            return false;
+        }
+
+        let min_progress_duration_ms = segment_duration
+            .filter(|duration| duration.is_finite() && *duration > 0.)
+            .map(|duration| 1000. * (duration / (playback_rate * 2.)))
+            .filter(|duration| duration.is_finite() && *duration > 0.)
+            .map(|duration| duration.max(ABANDON_MIN_PROGRESS_DURATION_MS))
+            .unwrap_or(ABANDON_MIN_PROGRESS_DURATION_MS);
+
         if !pending_quality.is_better_than(desired_quality)
             || desired_variant_bandwidth >= pending_variant_bandwidth
-            || progress_duration_ms < ABANDON_MIN_PROGRESS_DURATION_MS
+            || progress_duration_ms < min_progress_duration_ms
             || progress_samples < ABANDON_MIN_PROGRESS_SAMPLES
         {
             return false;
@@ -145,8 +159,9 @@ impl AdaptiveQualitySelector {
         let remaining_download_time = (remaining_bytes as f64) * 8. / measured_bandwidth;
         let replacement_download_time = replacement_total_bytes * 8. / measured_bandwidth;
 
-        remaining_download_time > buffer_level
-            && replacement_download_time + 0.25 < remaining_download_time
+        remaining_download_time > buffer_starvation_delay
+            && replacement_download_time < buffer_starvation_delay
+            && replacement_download_time + ABANDON_MIN_REPLACEMENT_GAIN_S < remaining_download_time
     }
 
     pub(crate) fn reset(&mut self) {
@@ -232,3 +247,72 @@ fn compute_bola_variant_id(
         })
         .map(|(variant, _)| variant.id())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::AdaptiveQualitySelector;
+    use crate::media_element::SegmentQualityContext;
+
+    #[test]
+    fn does_not_abandon_before_half_a_segment_elapsed() {
+        let selector = AdaptiveQualitySelector::new(5_000_000.);
+        let pending_quality = SegmentQualityContext::new(2., 10);
+        let desired_quality = SegmentQualityContext::new(1., 11);
+
+        assert!(!selector.should_abandon_media_request(
+            &pending_quality,
+            &desired_quality,
+            4_000_000,
+            2_000_000,
+            400_000,
+            Some(1_000_000),
+            1_900.,
+            4,
+            1.,
+            Some(4.),
+            3.,
+        ));
+    }
+
+    #[test]
+    fn abandons_when_replacement_beats_starvation_and_remaining_time() {
+        let selector = AdaptiveQualitySelector::new(5_000_000.);
+        let pending_quality = SegmentQualityContext::new(2., 10);
+        let desired_quality = SegmentQualityContext::new(1., 11);
+
+        assert!(selector.should_abandon_media_request(
+            &pending_quality,
+            &desired_quality,
+            4_000_000,
+            1_000_000,
+            250_000,
+            Some(1_000_000),
+            2_100.,
+            4,
+            1.,
+            Some(4.),
+            3.,
+        ));
+    }
+
+    #[test]
+    fn does_not_abandon_when_replacement_would_miss_starvation_deadline() {
+        let selector = AdaptiveQualitySelector::new(5_000_000.);
+        let pending_quality = SegmentQualityContext::new(2., 10);
+        let desired_quality = SegmentQualityContext::new(1., 11);
+
+        assert!(!selector.should_abandon_media_request(
+            &pending_quality,
+            &desired_quality,
+            4_000_000,
+            2_000_000,
+            250_000,
+            Some(1_000_000),
+            2_100.,
+            4,
+            1.,
+            Some(4.),
+            1.8,
+        ));
+    }
+}

src/rs-core/dispatcher/core/mod.rs

@@ -1172,8 +1172,12 @@ impl Dispatcher {
         let Some(pl_store) = self.playlist_store.as_ref() else {
             return;
         };
-
-        let buffer_level = self.media_element_ref.last_buffer_gap();
+        if pl_store.is_variant_locked() || !self.media_element_ref.can_monitor_abr_requests() {
+            return;
+        }
+        let Some(buffer_starvation_delay) = self.media_element_ref.starvation_delay() else {
+            return;
+        };
         let Some(pending_request) = self.requester.pending_segment_request(MediaType::Video) else {
             return;
         };
@@ -1200,6 +1204,9 @@ impl Dispatcher {
         ) else {
             return;
         };
+        let segment_duration = pending_context
+            .time_info()
+            .map(|time_info| time_info.duration());
 
         if self.adaptive_selector.should_abandon_media_request(
             pending_quality_context,
@@ -1210,7 +1217,9 @@ impl Dispatcher {
             pending_request.bytes_total(),
             pending_request.progress_duration_ms(),
             pending_request.progress_samples(),
-            buffer_level,
+            self.media_element_ref.wanted_speed(),
+            segment_duration,
+            buffer_starvation_delay,
         ) {
             log_info!("Core: Abandoning pending higher-quality video segment request");
             self.abort_segment_requests_with_type(MediaType::Video);

src/rs-core/media_element/mod.rs

@@ -201,6 +201,27 @@ impl MediaElementReference {
             .unwrap_or(0.)
     }
 
+    /// Returns whether current playback conditions make an ABR abandon decision meaningful.
+    pub(crate) fn can_monitor_abr_requests(&self) -> bool {
+        let Some(observation) = self.last_observation.as_ref() else {
+            return false;
+        };
+        observation.ready_state() >= 1
+            && !observation.paused()
+            && !observation.seeking()
+            && !observation.ended()
+            && self.wanted_speed.is_finite()
+            && self.wanted_speed > 0.
+    }
+
+    /// Returns the effective time left before starvation at the current playback rate.
+    pub(crate) fn starvation_delay(&self) -> Option<f64> {
+        if !self.can_monitor_abr_requests() {
+            return None;
+        }
+        Some(self.last_buffer_gap() / self.wanted_speed)
+    }
+
     /// Perform a seek, that is, move the current position to another one.
     ///
     /// Note that depending on that `MediaElementReference`'s state, seeks might

src/wasm/abi/wasm-functions.json

@@ -1131,6 +1131,21 @@
         "returnType": "void",
       },
     },
+    {
+      "wasmSymbol": "__web_event__request_progress",
+      "doc": ["Forward in-flight network request progress to wasm."],
+      "wasm": {
+        "kind": "method",
+        "args": [
+          { "name": "ptr", "type": "number" },
+          { "name": "requestId", "type": "number" },
+          { "name": "bytesLoaded", "type": "number" },
+          { "name": "bytesTotal", "type": "number" },
+          { "name": "durationMs", "type": "number" },
+        ],
+        "returnType": "void",
+      },
+    },
     {
       "wasmSymbol": "__web_event__request_failed",
       "doc": ["Forward a failed network request completion to wasm."],

src/wasm/abi/wasm-functions.jsonc

@@ -451,6 +451,16 @@ export interface WaspWasmExports {
     finalUrlLen: number,
     durationMs: number,
   ): void;
+  /**
+   * Forward in-flight network request progress to wasm.
+   */
+  __web_event__request_progress(
+    ptr: number,
+    requestId: number,
+    bytesLoaded: number,
+    bytesTotal: number,
+    durationMs: number,
+  ): void;
   /**
    * Forward a failed network request completion to wasm.
    */