mac: use config cache und wakeup for mac option runtime changes

remove the libmpv observer for the macOS specific options and use a
config cache + change callback for runtime changes. this is also a
preparation for new backends and generalises even more, since libmpv
functions can't and shouldn't be used in usual vo backends. for feature
parity the config cache is used.

2 files changed, 24 insertions, 18 deletions

diff --git a/osdep/macos/libmpv_helper.swift b/osdep/macos/libmpv_helper.swift
index 61c8483022..d1b00cf304 100644
--- a/osdep/macos/libmpv_helper.swift
+++ b/osdep/macos/libmpv_helper.swift
@@ -182,14 +182,6 @@ class LibmpvHelper {
         for ptr in cargs { free(UnsafeMutablePointer(mutating: ptr)) }
     }
 
-    func observeString(_ property: String) {
-        mpv_observe_property(mpvHandle, 0, property, MPV_FORMAT_STRING)
-    }
-
-    func observeFlag(_ property: String) {
-        mpv_observe_property(mpvHandle, 0, property, MPV_FORMAT_FLAG)
-    }
-
     // Unsafe function when called while using the render API
     func command(_ cmd: String) {
         if mpvHandle == nil { return }
diff --git a/osdep/macos/mpv_helper.swift b/osdep/macos/mpv_helper.swift
index 8a05f26cb1..0e207b994b 100644
--- a/osdep/macos/mpv_helper.swift
+++ b/osdep/macos/mpv_helper.swift
@@ -17,11 +17,15 @@
 
 import Cocoa
 
+typealias swift_wakeup_cb_fn = (@convention(c) (UnsafeMutableRawPointer?) -> Void)?
+
 class MPVHelper {
     var log: LogHelper
     var vo: UnsafeMutablePointer<vo>
     var optsCachePtr: UnsafeMutablePointer<m_config_cache>
     var optsPtr: UnsafeMutablePointer<mp_vo_opts>
+    var macOptsCachePtr: UnsafeMutablePointer<m_config_cache>
+    var macOptsPtr: UnsafeMutablePointer<macos_opts>
 
     // these computed properties return a local copy of the struct accessed:
     // - don't use if you rely on the pointers
@@ -29,9 +33,10 @@ class MPVHelper {
     var vout: vo { get { return vo.pointee } }
     var optsCache: m_config_cache { get { return optsCachePtr.pointee } }
     var opts: mp_vo_opts { get { return optsPtr.pointee } }
+    var macOptsCache: m_config_cache { get { return macOptsCachePtr.pointee } }
+    var macOpts: macos_opts { get { return macOptsPtr.pointee } }
 
     var input: OpaquePointer { get { return vout.input_ctx } }
-    var macOpts: macos_opts = macos_opts()
 
     init(_ vo: UnsafeMutablePointer<vo>, _ log: LogHelper) {
         self.vo = vo
@@ -47,14 +52,15 @@ class MPVHelper {
         optsCachePtr = cache
         optsPtr = UnsafeMutablePointer<mp_vo_opts>(OpaquePointer(cache.pointee.opts))
 
-        guard let ptr = mp_get_config_group(vo,
-                                            vo.pointee.global,
-                                            app.getMacOSConf()) else
+        guard let macCache = m_config_cache_alloc(vo,
+                                                  vo.pointee.global,
+                                                  app.getMacOSConf()) else
         {
             // will never be hit, mp_get_config_group asserts for invalid groups
-            return
+            exit(1)
         }
-        macOpts = UnsafeMutablePointer<macos_opts>(OpaquePointer(ptr)).pointee
+        macOptsCachePtr = macCache
+        macOptsPtr = UnsafeMutablePointer<macos_opts>(OpaquePointer(macCache.pointee.opts))
     }
 
     func canBeDraggedAt(_ pos: NSPoint) -> Bool {
@@ -74,25 +80,33 @@ class MPVHelper {
         mp_input_put_wheel(input, mpkey, delta)
     }
 
-    func nextChangedConfig(property: inout UnsafeMutableRawPointer?) -> Bool {
+    func nextChangedOption(property: inout UnsafeMutableRawPointer?) -> Bool {
         return m_config_cache_get_next_changed(optsCachePtr, &property)
     }
 
-    func setConfigProperty(fullscreen: Bool) {
+    func setOption(fullscreen: Bool) {
         optsPtr.pointee.fullscreen = fullscreen
         m_config_cache_write_opt(optsCachePtr, UnsafeMutableRawPointer(&optsPtr.pointee.fullscreen))
     }
 
-    func setConfigProperty(minimized: Bool) {
+    func setOption(minimized: Bool) {
         optsPtr.pointee.window_minimized = Int32(minimized)
         m_config_cache_write_opt(optsCachePtr, UnsafeMutableRawPointer(&optsPtr.pointee.window_minimized))
     }
 
-    func setConfigProperty(maximized: Bool) {
+    func setOption(maximized: Bool) {
         optsPtr.pointee.window_maximized = Int32(maximized)
         m_config_cache_write_opt(optsCachePtr, UnsafeMutableRawPointer(&optsPtr.pointee.window_maximized))
     }
 
+    func setMacOptionCallback(_ callback: swift_wakeup_cb_fn, context object: AnyObject) {
+        m_config_cache_set_wakeup_cb(macOptsCachePtr, callback, MPVHelper.bridge(obj: object))
+    }
+
+    func nextChangedMacOption(property: inout UnsafeMutableRawPointer?) -> Bool {
+        return m_config_cache_get_next_changed(macOptsCachePtr, &property)
+    }
+
     func command(_ cmd: String) {
         let cCmd = UnsafePointer<Int8>(strdup(cmd))
         let mpvCmd = mp_input_parse_cmd(input, bstr0(cCmd), "")