feat(presenter): subtitle/audio delay, mute, and volume query across the full stack

crates/erika_capi/include/erika.h

@@ -419,8 +419,21 @@ ErikaStatus erika_presenter_close(ErikaPresenterHandle *handle);
 ErikaStatus erika_presenter_seek(ErikaPresenterHandle *handle, uint64_t position_micros);
 ErikaStatus erika_presenter_set_playback_rate(ErikaPresenterHandle *handle, double rate);
 ErikaStatus erika_presenter_set_volume(ErikaPresenterHandle *handle, double volume);
+/* get_volume reports the saved user volume even while muted so hosts can
+ * restore their slider position on unmute. */
+ErikaStatus erika_presenter_get_volume(ErikaPresenterHandle *handle, double *out_volume);
+/* Mute silences output without discarding the saved volume; set_volume while
+ * muted updates the saved value and is applied on unmute. */
+ErikaStatus erika_presenter_set_muted(ErikaPresenterHandle *handle, bool muted);
+ErikaStatus erika_presenter_muted(ErikaPresenterHandle *handle, bool *out_muted);
 ErikaStatus erika_presenter_set_upscaler(ErikaPresenterHandle *handle, int32_t mode);
 ErikaStatus erika_presenter_set_subtitle_scale(ErikaPresenterHandle *handle, double scale);
+/* Delays follow mpv semantics: positive sub-delay shows subtitles later,
+ * positive audio-delay plays audio later than video. seconds is clamped to
+ * ±60 (subtitle) / ±10 (audio). Negative subtitle delay is limited by decode
+ * lookahead; audio delay applies from the next decoded frame. */
+ErikaStatus erika_presenter_set_subtitle_delay(ErikaPresenterHandle *handle, double seconds);
+ErikaStatus erika_presenter_set_audio_delay(ErikaPresenterHandle *handle, double seconds);
 ErikaStatus erika_presenter_set_output_headroom(
     ErikaPresenterHandle *handle,
     float headroom,

crates/erika_capi/src/android_jni.rs

@@ -755,6 +755,23 @@ unsafe fn invoke_presenter(
             let scale = required_f64(args, "scale")?;
             status_value(unsafe { erika_presenter_set_subtitle_scale(handle, scale) })
         }
+        "setSubtitleDelay" => {
+            let seconds = required_f64(args, "seconds")?;
+            status_value(unsafe { erika_presenter_set_subtitle_delay(handle, seconds) })
+        }
+        "setAudioDelay" => {
+            let seconds = required_f64(args, "seconds")?;
+            status_value(unsafe { erika_presenter_set_audio_delay(handle, seconds) })
+        }
+        "setMuted" => {
+            let muted = required_bool(args, "muted")?;
+            status_value(unsafe { erika_presenter_set_muted(handle, muted) })
+        }
+        "getVolume" => {
+            let mut volume = 1.0f64;
+            call_status(unsafe { erika_presenter_get_volume(handle, &mut volume) })?;
+            Ok(json!(volume))
+        }
         "setOutputHeadroom" => {
             let headroom = required_f64(args, "headroom")? as f32;
             let known =
@@ -1374,6 +1391,10 @@ fn optional_bool(args: &Map<String, Value>, name: &str) -> Option<bool> {
     args.get(name).and_then(Value::as_bool)
 }
 
+fn required_bool(args: &Map<String, Value>, name: &str) -> Result<bool, String> {
+    optional_bool(args, name).ok_or_else(|| format!("{name} is required"))
+}
+
 fn c_string(value: &str, name: &str) -> Result<CString, String> {
     CString::new(value).map_err(|_| format!("{name} contains an embedded NUL byte"))
 }

crates/erika_capi/src/lib.rs

@@ -1525,6 +1525,111 @@ pub unsafe extern "C" fn erika_presenter_set_volume(
     })
 }
 
+#[cfg(any(
+    target_os = "macos",
+    target_os = "ios",
+    target_os = "windows",
+    target_os = "android"
+))]
+/// # Safety
+/// `handle` must be a live pointer returned by `erika_presenter_create*` and
+/// `out_volume` must point to writable memory for one `f64`.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn erika_presenter_get_volume(
+    handle: *mut ErikaPresenterHandle,
+    out_volume: *mut f64,
+) -> ErikaStatus {
+    if out_volume.is_null() {
+        return ErikaStatus::NullPointer;
+    }
+    with_presenter_mut(handle, |handle| {
+        let volume = handle.presenter.volume();
+        unsafe { *out_volume = volume };
+        ErikaStatus::Ok
+    })
+}
+
+#[cfg(any(
+    target_os = "macos",
+    target_os = "ios",
+    target_os = "windows",
+    target_os = "android"
+))]
+/// # Safety
+/// `handle` must be a live pointer returned by `erika_presenter_create*`.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn erika_presenter_set_muted(
+    handle: *mut ErikaPresenterHandle,
+    muted: bool,
+) -> ErikaStatus {
+    with_presenter_mut(handle, |handle| {
+        handle.presenter.set_muted(muted);
+        ErikaStatus::Ok
+    })
+}
+
+#[cfg(any(
+    target_os = "macos",
+    target_os = "ios",
+    target_os = "windows",
+    target_os = "android"
+))]
+/// # Safety
+/// `handle` must be a live pointer returned by `erika_presenter_create*` and
+/// `out_muted` must point to writable memory for one `bool`.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn erika_presenter_muted(
+    handle: *mut ErikaPresenterHandle,
+    out_muted: *mut bool,
+) -> ErikaStatus {
+    if out_muted.is_null() {
+        return ErikaStatus::NullPointer;
+    }
+    with_presenter_mut(handle, |handle| {
+        let muted = handle.presenter.muted();
+        unsafe { *out_muted = muted };
+        ErikaStatus::Ok
+    })
+}
+
+#[cfg(any(
+    target_os = "macos",
+    target_os = "ios",
+    target_os = "windows",
+    target_os = "android"
+))]
+/// # Safety
+/// `handle` must be a live pointer returned by `erika_presenter_create*`.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn erika_presenter_set_subtitle_delay(
+    handle: *mut ErikaPresenterHandle,
+    seconds: f64,
+) -> ErikaStatus {
+    with_presenter_mut(handle, |handle| {
+        handle.presenter.set_subtitle_delay(seconds);
+        ErikaStatus::Ok
+    })
+}
+
+#[cfg(any(
+    target_os = "macos",
+    target_os = "ios",
+    target_os = "windows",
+    target_os = "android"
+))]
+/// # Safety
+/// `handle` must be a live pointer returned by `erika_presenter_create*`.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn erika_presenter_set_audio_delay(
+    handle: *mut ErikaPresenterHandle,
+    seconds: f64,
+) -> ErikaStatus {
+    with_presenter_mut(handle, |handle| {
+        handle.presenter.set_audio_delay(seconds);
+        ErikaStatus::Ok
+    })
+}
+
 #[cfg(any(
     target_os = "macos",
     target_os = "ios",
@@ -2285,6 +2390,82 @@ pub unsafe extern "C" fn erika_presenter_set_volume(
     ErikaStatus::PlayerError
 }
 
+#[cfg(not(any(
+    target_os = "macos",
+    target_os = "ios",
+    target_os = "windows",
+    target_os = "android"
+)))]
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn erika_presenter_get_volume(
+    _handle: *mut std::ffi::c_void,
+    out_volume: *mut f64,
+) -> ErikaStatus {
+    if out_volume.is_null() {
+        return ErikaStatus::NullPointer;
+    }
+    ErikaStatus::PlayerError
+}
+
+#[cfg(not(any(
+    target_os = "macos",
+    target_os = "ios",
+    target_os = "windows",
+    target_os = "android"
+)))]
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn erika_presenter_set_muted(
+    _handle: *mut std::ffi::c_void,
+    _muted: bool,
+) -> ErikaStatus {
+    ErikaStatus::PlayerError
+}
+
+#[cfg(not(any(
+    target_os = "macos",
+    target_os = "ios",
+    target_os = "windows",
+    target_os = "android"
+)))]
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn erika_presenter_muted(
+    _handle: *mut std::ffi::c_void,
+    out_muted: *mut bool,
+) -> ErikaStatus {
+    if out_muted.is_null() {
+        return ErikaStatus::NullPointer;
+    }
+    ErikaStatus::PlayerError
+}
+
+#[cfg(not(any(
+    target_os = "macos",
+    target_os = "ios",
+    target_os = "windows",
+    target_os = "android"
+)))]
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn erika_presenter_set_subtitle_delay(
+    _handle: *mut std::ffi::c_void,
+    _seconds: f64,
+) -> ErikaStatus {
+    ErikaStatus::PlayerError
+}
+
+#[cfg(not(any(
+    target_os = "macos",
+    target_os = "ios",
+    target_os = "windows",
+    target_os = "android"
+)))]
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn erika_presenter_set_audio_delay(
+    _handle: *mut std::ffi::c_void,
+    _seconds: f64,
+) -> ErikaStatus {
+    ErikaStatus::PlayerError
+}
+
 #[cfg(not(any(
     target_os = "macos",
     target_os = "ios",
@@ -3644,6 +3825,111 @@ mod tests {
         unsafe { erika_presenter_destroy(handle) };
     }
 
+    #[cfg(any(
+        target_os = "macos",
+        target_os = "ios",
+        target_os = "windows",
+        target_os = "android"
+    ))]
+    #[test]
+    fn c_presenter_volume_and_mute_round_trip() {
+        let mut volume = f64::NAN;
+        assert_eq!(
+            unsafe { erika_presenter_get_volume(std::ptr::null_mut(), &mut volume) },
+            ErikaStatus::NullPointer
+        );
+        let mut muted = false;
+        assert_eq!(
+            unsafe { erika_presenter_set_muted(std::ptr::null_mut(), true) },
+            ErikaStatus::NullPointer
+        );
+        assert_eq!(
+            unsafe { erika_presenter_muted(std::ptr::null_mut(), &mut muted) },
+            ErikaStatus::NullPointer
+        );
+
+        let handle = erika_presenter_create();
+        assert!(!handle.is_null());
+        assert_eq!(
+            unsafe { erika_presenter_get_volume(handle, std::ptr::null_mut()) },
+            ErikaStatus::NullPointer
+        );
+        assert_eq!(
+            unsafe { erika_presenter_muted(handle, std::ptr::null_mut()) },
+            ErikaStatus::NullPointer
+        );
+
+        assert_eq!(
+            unsafe { erika_presenter_set_volume(handle, 0.4) },
+            ErikaStatus::Ok
+        );
+        assert_eq!(
+            unsafe { erika_presenter_set_muted(handle, true) },
+            ErikaStatus::Ok
+        );
+        assert_eq!(
+            unsafe { erika_presenter_muted(handle, &mut muted) },
+            ErikaStatus::Ok
+        );
+        assert!(muted);
+        // Muting must not clobber the saved volume the getter reports.
+        assert_eq!(
+            unsafe { erika_presenter_get_volume(handle, &mut volume) },
+            ErikaStatus::Ok
+        );
+        assert!((volume - 0.4).abs() < 0.000_001);
+
+        assert_eq!(
+            unsafe { erika_presenter_set_muted(handle, false) },
+            ErikaStatus::Ok
+        );
+        assert_eq!(
+            unsafe { erika_presenter_muted(handle, &mut muted) },
+            ErikaStatus::Ok
+        );
+        assert!(!muted);
+        unsafe { erika_presenter_destroy(handle) };
+    }
+
+    #[cfg(any(
+        target_os = "macos",
+        target_os = "ios",
+        target_os = "windows",
+        target_os = "android"
+    ))]
+    #[test]
+    fn c_presenter_delay_setters_accept_valid_handle() {
+        assert_eq!(
+            unsafe { erika_presenter_set_subtitle_delay(std::ptr::null_mut(), 1.0) },
+            ErikaStatus::NullPointer
+        );
+        assert_eq!(
+            unsafe { erika_presenter_set_audio_delay(std::ptr::null_mut(), 1.0) },
+            ErikaStatus::NullPointer
+        );
+
+        let handle = erika_presenter_create();
+        assert!(!handle.is_null());
+        assert_eq!(
+            unsafe { erika_presenter_set_subtitle_delay(handle, 2.5) },
+            ErikaStatus::Ok
+        );
+        assert_eq!(
+            unsafe { erika_presenter_set_audio_delay(handle, -0.5) },
+            ErikaStatus::Ok
+        );
+        // Out-of-range and non-finite values are clamped/ignored, never errors.
+        assert_eq!(
+            unsafe { erika_presenter_set_subtitle_delay(handle, f64::NAN) },
+            ErikaStatus::Ok
+        );
+        assert_eq!(
+            unsafe { erika_presenter_set_audio_delay(handle, 1_000.0) },
+            ErikaStatus::Ok
+        );
+        unsafe { erika_presenter_destroy(handle) };
+    }
+
     #[cfg(any(
         target_os = "macos",
         target_os = "ios",

packages/erika_flutter/android/src/main/kotlin/dev/aimesoft/erika_flutter/ErikaFlutterPlugin.kt

@@ -1692,6 +1692,7 @@ class ErikaFlutterPlugin :
             "seek",
             "setUpscaler",
             "setSubtitleScale",
+            "setSubtitleDelay",
             "addExternalSubtitle",
             "removeSubtitleTrack",
             "loadDanmakuFile",
@@ -1718,8 +1719,12 @@ class ErikaFlutterPlugin :
             "seek",
             "setPlaybackRate",
             "setVolume",
+            "getVolume",
+            "setMuted",
             "setUpscaler",
             "setSubtitleScale",
+            "setSubtitleDelay",
+            "setAudioDelay",
             "getUpscalerStatus",
             "getOutputStatus",
             "getPresenterStats",