feat(presenter): add mute and volume query

crates/erika/src/presenter.rs

@@ -248,6 +248,8 @@ pub struct PresenterRuntime {
     current_surface_metrics: Option<SurfaceMetrics>,
     current_danmaku_viewport: Option<DanmakuViewport>,
     subtitle_font_scale: f64,
+    muted: bool,
+    saved_volume: f64,
     subtitles: SubtitleFrameState,
     overlay: OverlayTimeline,
     render_test_pattern_when_idle: bool,
@@ -550,6 +552,8 @@ impl PresenterRuntime {
             current_surface_metrics: None,
             current_danmaku_viewport: None,
             subtitle_font_scale: DEFAULT_SUBTITLE_FONT_SCALE,
+            muted: false,
+            saved_volume: 1.0,
             subtitles: SubtitleFrameState::default(),
             overlay: config.overlay,
             render_test_pattern_when_idle: config.render_test_pattern_when_idle,
@@ -693,11 +697,28 @@ impl PresenterRuntime {
     }
 
     pub fn set_volume(&mut self, volume: f64) {
-        self.audio_output.set_volume(volume as f32);
+        self.saved_volume = normalize_presenter_volume(volume);
+        let output = effective_output_volume(self.muted, self.saved_volume);
+        self.audio_output.set_volume(output as f32);
     }
 
+    /// Returns the user-selected volume. While muted the audio output runs at
+    /// zero gain, but this still reports the saved volume so UIs can restore
+    /// the slider position on unmute.
     pub fn volume(&self) -> f64 {
-        self.audio_output.volume() as f64
+        self.saved_volume
+    }
+
+    /// Mutes or unmutes audio without discarding the saved volume. Volume
+    /// changes made while muted are remembered and applied on unmute.
+    pub fn set_muted(&mut self, muted: bool) {
+        self.muted = muted;
+        let output = effective_output_volume(self.muted, self.saved_volume);
+        self.audio_output.set_volume(output as f32);
+    }
+
+    pub fn muted(&self) -> bool {
+        self.muted
     }
 
     pub fn set_subtitle_scale(&mut self, scale: f64) {
@@ -2158,6 +2179,18 @@ fn normalize_subtitle_font_scale(scale: f64) -> f64 {
     }
 }
 
+fn normalize_presenter_volume(volume: f64) -> f64 {
+    if volume.is_finite() {
+        volume.clamp(0.0, 1.0)
+    } else {
+        1.0
+    }
+}
+
+fn effective_output_volume(muted: bool, saved_volume: f64) -> f64 {
+    if muted { 0.0 } else { saved_volume }
+}
+
 fn bump_generation(current_generation: &mut u64, danmaku_generation: &mut u64) {
     *danmaku_generation = danmaku_generation.saturating_add(1).max(1);
     *current_generation = current_generation
@@ -3323,6 +3356,36 @@ Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
         assert_eq!(presenter.volume(), 1.0);
     }
 
+    #[test]
+    #[cfg(feature = "wgpu")]
+    fn presenter_mute_preserves_saved_volume() {
+        let mut presenter = PresenterRuntime::new(PresenterConfig::default()).unwrap();
+
+        presenter.set_volume(0.6);
+        presenter.set_muted(true);
+        assert!(presenter.muted());
+        // Output gain is silenced while the reported volume stays at the
+        // user's saved value.
+        assert_eq!(presenter.audio_output.volume(), 0.0);
+        assert!((presenter.volume() - 0.6).abs() < 0.000_001);
+
+        // Volume changes while muted are remembered but not applied yet.
+        presenter.set_volume(0.3);
+        assert_eq!(presenter.audio_output.volume(), 0.0);
+        assert!((presenter.volume() - 0.3).abs() < 0.000_001);
+
+        presenter.set_muted(false);
+        assert!(!presenter.muted());
+        assert!((f64::from(presenter.audio_output.volume()) - 0.3).abs() < 0.000_001);
+    }
+
+    #[test]
+    fn effective_output_volume_silences_only_while_muted() {
+        assert_eq!(effective_output_volume(true, 0.7), 0.0);
+        assert_eq!(effective_output_volume(false, 0.7), 0.7);
+        assert_eq!(effective_output_volume(false, 0.0), 0.0);
+    }
+
     #[test]
     fn surface_dimensions_are_converted_to_full_output_danmaku_viewport() {
         let viewport = surface_metrics_to_viewport(SurfaceMetrics::new(1600, 900, 2.0));

crates/erika_capi/include/erika.h

@@ -436,6 +436,13 @@ 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);
 ErikaStatus erika_presenter_set_output_headroom(

crates/erika_capi/src/android_jni.rs

@@ -763,6 +763,15 @@ unsafe fn invoke_presenter(
             let scale = required_f64(args, "scale")?;
             status_value(unsafe { erika_presenter_set_subtitle_scale(handle, scale) })
         }
+        "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 =
@@ -1382,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

@@ -1637,6 +1637,73 @@ pub unsafe extern "C" fn erika_presenter_set_volume(
     target_os = "android",
     target_env = "ohos"
 ))]
+/// # 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"
+))]
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn erika_presenter_set_upscaler(
     handle: *mut ErikaPresenterHandle,
@@ -2434,6 +2501,54 @@ pub unsafe extern "C" fn erika_presenter_set_volume(
     target_env = "ohos"
 )))]
 #[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_upscaler(
     _handle: *mut std::ffi::c_void,
     _mode: i32,
@@ -4092,6 +4207,72 @@ mod tests {
         target_env = "ohos"
     ))]
     #[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_set_upscaler_accepts_valid_handle() {
         assert_eq!(
             unsafe {

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

@@ -1718,6 +1718,8 @@ class ErikaFlutterPlugin :
             "seek",
             "setPlaybackRate",
             "setVolume",
+            "getVolume",
+            "setMuted",
             "setUpscaler",
             "setSubtitleScale",
             "getUpscalerStatus",