macos

macos/Runner/MainFlutterWindow.swift

@@ -4,10 +4,18 @@ import FlutterMacOS
 class MainFlutterWindow: NSWindow {
   override func awakeFromNib() {
     let flutterViewController = FlutterViewController()
+
+    // Enable transparency for Metal layer behind Flutter
+    self.backgroundColor = NSColor.clear
+    flutterViewController.backgroundColor = NSColor.clear
+
     let windowFrame = self.frame
     self.contentViewController = flutterViewController
     self.setFrame(windowFrame, display: true)
 
+    // Register MPV player plugin for video playback
+    MpvPlayerPlugin.register(with: flutterViewController.registrar(forPlugin: "MpvPlayerPlugin"))
+
     RegisterGeneratedPlugins(registry: flutterViewController)
 
     super.awakeFromNib()

macos/Runner/MpvPlayer/MpvPlayerCore.swift

@@ -0,0 +1,382 @@
+import Cocoa
+import Libmpv
+
+/// Protocol for receiving player events
+protocol MpvPlayerDelegate: AnyObject {
+    func onPropertyChange(name: String, value: Any?)
+    func onEvent(name: String, data: [String: Any]?)
+}
+
+// Workaround for MoltenVK problems that cause flicker
+// https://github.com/mpv-player/mpv/pull/13651
+private class MetalLayer: CAMetalLayer {
+    override var drawableSize: CGSize {
+        get { return super.drawableSize }
+        set {
+            if Int(newValue.width) > 1 && Int(newValue.height) > 1 {
+                super.drawableSize = newValue
+            }
+        }
+    }
+
+    // Fix for target-colorspace-hint - needs main thread for EDR
+    override var wantsExtendedDynamicRangeContent: Bool {
+        get { return super.wantsExtendedDynamicRangeContent }
+        set {
+            if Thread.isMainThread {
+                super.wantsExtendedDynamicRangeContent = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    super.wantsExtendedDynamicRangeContent = newValue
+                }
+            }
+        }
+    }
+}
+
+/// Core MPV player using Metal rendering
+class MpvPlayerCore: NSObject {
+
+    // MARK: - Properties
+
+    private var metalLayer: MetalLayer?
+    private var mpv: OpaquePointer?
+    private weak var window: NSWindow?
+    private lazy var queue = DispatchQueue(label: "mpv", qos: .userInitiated)
+
+    weak var delegate: MpvPlayerDelegate?
+
+    private(set) var isInitialized = false
+
+    // MARK: - Initialization
+
+    func initialize(in window: NSWindow) -> Bool {
+        guard !isInitialized else {
+            print("[MpvPlayerCore] Already initialized")
+            return true
+        }
+
+        guard let contentView = window.contentView else {
+            print("[MpvPlayerCore] No content view")
+            return false
+        }
+
+        self.window = window
+
+        // Create Metal layer for video rendering
+        let layer = MetalLayer()
+        layer.frame = contentView.bounds
+        if let screen = window.screen ?? NSScreen.main {
+            layer.contentsScale = screen.backingScaleFactor
+        }
+        layer.framebufferOnly = true
+        layer.autoresizingMask = [.layerWidthSizable, .layerHeightSizable]
+
+        metalLayer = layer
+
+        // Ensure contentView has a layer and add our Metal layer
+        contentView.wantsLayer = true
+        contentView.layer?.addSublayer(layer)
+
+        print("[MpvPlayerCore] Metal layer added, frame: \(layer.frame)")
+
+        // Initialize MPV with this Metal layer
+        guard setupMpv() else {
+            print("[MpvPlayerCore] Failed to setup MPV")
+            layer.removeFromSuperlayer()
+            metalLayer = nil
+            return false
+        }
+
+        isInitialized = true
+        print("[MpvPlayerCore] Initialized successfully with MPV")
+        return true
+    }
+
+    private func setupMpv() -> Bool {
+        guard let metalLayer = metalLayer else { return false }
+
+        mpv = mpv_create()
+        guard mpv != nil else {
+            print("[MpvPlayerCore] Failed to create MPV context")
+            return false
+        }
+
+        // Logging
+        #if DEBUG
+        checkError(mpv_request_log_messages(mpv, "info"))
+        #else
+        checkError(mpv_request_log_messages(mpv, "warn"))
+        #endif
+
+        // Set the Metal layer as the render target (must use local var for &)
+        var layer = metalLayer
+        checkError(mpv_set_option(mpv, "wid", MPV_FORMAT_INT64, &layer))
+
+        // Video output settings for Metal/Vulkan
+        checkError(mpv_set_option_string(mpv, "vo", "gpu-next"))
+        checkError(mpv_set_option_string(mpv, "gpu-api", "vulkan"))
+        checkError(mpv_set_option_string(mpv, "gpu-context", "moltenvk"))
+        checkError(mpv_set_option_string(mpv, "hwdec", "videotoolbox"))
+
+        // Initialize MPV
+        let initResult = mpv_initialize(mpv)
+        if initResult < 0 {
+            print("[MpvPlayerCore] mpv_initialize failed: \(String(cString: mpv_error_string(initResult)))")
+            mpv_terminate_destroy(mpv)
+            mpv = nil
+            return false
+        }
+
+        // Set up wakeup callback for event handling
+        mpv_set_wakeup_callback(mpv, { ctx in
+            let core = Unmanaged<MpvPlayerCore>.fromOpaque(ctx!).takeUnretainedValue()
+            core.readEvents()
+        }, UnsafeMutableRawPointer(Unmanaged.passUnretained(self).toOpaque()))
+
+        print("[MpvPlayerCore] MPV initialized successfully")
+        return true
+    }
+
+    // MARK: - MPV Properties and Commands
+
+    func setProperty(_ name: String, value: String) {
+        guard mpv != nil else { return }
+        mpv_set_property_string(mpv, name, value)
+    }
+
+    func getProperty(_ name: String) -> String? {
+        guard mpv != nil else { return nil }
+        let cstr = mpv_get_property_string(mpv, name)
+        defer { mpv_free(cstr) }
+        return cstr.map { String(cString: $0) }
+    }
+
+    func observeProperty(_ name: String, format: String) {
+        guard mpv != nil else { return }
+
+        let mpvFormat: mpv_format
+        switch format {
+        case "double": mpvFormat = MPV_FORMAT_DOUBLE
+        case "flag": mpvFormat = MPV_FORMAT_FLAG
+        case "node": mpvFormat = MPV_FORMAT_NODE
+        case "string": mpvFormat = MPV_FORMAT_STRING
+        default: return
+        }
+
+        mpv_observe_property(mpv, 0, name, mpvFormat)
+    }
+
+    func command(_ args: [String]) {
+        guard mpv != nil, !args.isEmpty else { return }
+        command(args[0], args: Array(args.dropFirst()))
+    }
+
+    // MARK: - Visibility
+
+    func setVisible(_ visible: Bool) {
+        guard let layer = metalLayer else { return }
+
+        if visible {
+            // Re-insert after background layer but before Flutter control views
+            layer.removeFromSuperlayer()
+            if let superlayer = window?.contentView?.layer {
+                superlayer.insertSublayer(layer, at: 1)
+            }
+        }
+
+        layer.isHidden = !visible
+        print("[MpvPlayerCore] setVisible(\(visible))")
+    }
+
+    func updateFrame(_ frame: CGRect? = nil) {
+        guard let metalLayer = metalLayer else { return }
+
+        if let frame = frame {
+            metalLayer.frame = frame
+        } else if let contentView = window?.contentView {
+            metalLayer.frame = contentView.bounds
+        }
+
+        // Update drawable size for proper scaling
+        if let screen = window?.screen ?? NSScreen.main {
+            let scale = screen.backingScaleFactor
+            metalLayer.drawableSize = CGSize(
+                width: metalLayer.frame.width * scale,
+                height: metalLayer.frame.height * scale
+            )
+        }
+
+        print("[MpvPlayerCore] updateFrame: \(metalLayer.frame)")
+    }
+
+    // MARK: - Private Helpers
+
+    private func command(_ cmd: String, args: [String] = []) {
+        guard mpv != nil else { return }
+
+        // Build array of C strings for mpv_command
+        var cargs: [UnsafeMutablePointer<CChar>?] = ([cmd] + args).map { strdup($0) }
+        cargs.append(nil) // null-terminate
+        defer {
+            for ptr in cargs {
+                free(ptr)
+            }
+        }
+
+        // mpv_command expects UnsafePointer, use withUnsafeBufferPointer for the conversion
+        cargs.withUnsafeBufferPointer { buffer in
+            var constPtrs = buffer.map { UnsafePointer($0) }
+            _ = mpv_command(mpv, &constPtrs)
+        }
+    }
+
+    private func readEvents() {
+        queue.async { [weak self] in
+            guard let self = self, let mpv = self.mpv else { return }
+
+            while true {
+                let event = mpv_wait_event(mpv, 0)
+                guard let eventPtr = event else { break }
+
+                if eventPtr.pointee.event_id == MPV_EVENT_NONE {
+                    break
+                }
+
+                self.handleEvent(eventPtr.pointee)
+            }
+        }
+    }
+
+    private func handleEvent(_ event: mpv_event) {
+        switch event.event_id {
+        case MPV_EVENT_PROPERTY_CHANGE:
+            guard let data = event.data else { break }
+            let property = data.assumingMemoryBound(to: mpv_event_property.self).pointee
+            let name = String(cString: property.name)
+            handlePropertyChange(name: name, property: property)
+
+        case MPV_EVENT_FILE_LOADED:
+            DispatchQueue.main.async {
+                self.delegate?.onEvent(name: "file-loaded", data: nil)
+            }
+
+        case MPV_EVENT_END_FILE:
+            DispatchQueue.main.async {
+                self.delegate?.onEvent(name: "end-file", data: nil)
+            }
+
+        case MPV_EVENT_SHUTDOWN:
+            print("[MpvPlayerCore] MPV shutdown event")
+
+        case MPV_EVENT_LOG_MESSAGE:
+            if let msgPtr = event.data?.assumingMemoryBound(to: mpv_event_log_message.self) {
+                let msg = msgPtr.pointee
+                if let prefix = msg.prefix, let level = msg.level, let text = msg.text {
+                    print("[MPV:\(String(cString: prefix))] \(String(cString: level)): \(String(cString: text))", terminator: "")
+                }
+            }
+
+        default:
+            break
+        }
+    }
+
+    private func handlePropertyChange(name: String, property: mpv_event_property) {
+        var value: Any?
+
+        switch property.format {
+        case MPV_FORMAT_DOUBLE:
+            if let ptr = property.data {
+                value = ptr.assumingMemoryBound(to: Double.self).pointee
+            }
+
+        case MPV_FORMAT_FLAG:
+            if let ptr = property.data {
+                value = ptr.assumingMemoryBound(to: Int32.self).pointee != 0
+            }
+
+        case MPV_FORMAT_NODE:
+            if let ptr = property.data {
+                let node = ptr.assumingMemoryBound(to: mpv_node.self).pointee
+                value = convertNode(node)
+            }
+
+        case MPV_FORMAT_STRING:
+            if let ptr = property.data {
+                let cstr = ptr.assumingMemoryBound(to: UnsafePointer<CChar>?.self).pointee
+                value = cstr.map { String(cString: $0) }
+            }
+
+        default:
+            break
+        }
+
+        DispatchQueue.main.async {
+            self.delegate?.onPropertyChange(name: name, value: value)
+        }
+    }
+
+    private func convertNode(_ node: mpv_node) -> Any? {
+        switch node.format {
+        case MPV_FORMAT_STRING:
+            return node.u.string.map { String(cString: $0) }
+
+        case MPV_FORMAT_FLAG:
+            return node.u.flag != 0
+
+        case MPV_FORMAT_INT64:
+            return node.u.int64
+
+        case MPV_FORMAT_DOUBLE:
+            return node.u.double_
+
+        case MPV_FORMAT_NODE_ARRAY:
+            guard let list = node.u.list?.pointee else { return nil }
+            var array = [Any]()
+            for i in 0..<Int(list.num) {
+                if let item = convertNode(list.values[i]) {
+                    array.append(item)
+                }
+            }
+            return array
+
+        case MPV_FORMAT_NODE_MAP:
+            guard let list = node.u.list?.pointee else { return nil }
+            var dict = [String: Any]()
+            for i in 0..<Int(list.num) {
+                if let key = list.keys?[i].map({ String(cString: $0) }),
+                   let val = convertNode(list.values[i]) {
+                    dict[key] = val
+                }
+            }
+            return dict
+
+        default:
+            return nil
+        }
+    }
+
+    private func checkError(_ status: CInt) {
+        if status < 0 {
+            print("[MpvPlayerCore] MPV error: \(String(cString: mpv_error_string(status)))")
+        }
+    }
+
+    // MARK: - Cleanup
+
+    func dispose() {
+        if let mpv = mpv {
+            mpv_terminate_destroy(mpv)
+            self.mpv = nil
+        }
+        metalLayer?.removeFromSuperlayer()
+        metalLayer = nil
+        isInitialized = false
+        print("[MpvPlayerCore] Disposed")
+    }
+
+    deinit {
+        dispose()
+    }
+}

macos/Runner/MpvPlayer/MpvPlayerPlugin.swift

@@ -0,0 +1,249 @@
+import Cocoa
+import FlutterMacOS
+
+/// Flutter plugin that bridges MPV player to Dart via method and event channels
+class MpvPlayerPlugin: NSObject, FlutterPlugin, FlutterStreamHandler, MpvPlayerDelegate {
+
+    // MARK: - Properties
+
+    private var playerCore: MpvPlayerCore?
+    private var eventSink: FlutterEventSink?
+    private weak var registrar: FlutterPluginRegistrar?
+
+    // MARK: - FlutterPlugin Registration
+
+    static func register(with registrar: FlutterPluginRegistrar) {
+        // Method channel for commands
+        let methodChannel = FlutterMethodChannel(
+            name: "com.plezy/mpv_player",
+            binaryMessenger: registrar.messenger
+        )
+
+        // Event channel for state updates
+        let eventChannel = FlutterEventChannel(
+            name: "com.plezy/mpv_player/events",
+            binaryMessenger: registrar.messenger
+        )
+
+        let instance = MpvPlayerPlugin()
+        instance.registrar = registrar
+
+        registrar.addMethodCallDelegate(instance, channel: methodChannel)
+        eventChannel.setStreamHandler(instance)
+
+        print("[MpvPlayerPlugin] Registered with Flutter")
+    }
+
+    // MARK: - FlutterStreamHandler
+
+    func onListen(withArguments arguments: Any?, eventSink events: @escaping FlutterEventSink) -> FlutterError? {
+        self.eventSink = events
+        print("[MpvPlayerPlugin] Event stream connected")
+        return nil
+    }
+
+    func onCancel(withArguments arguments: Any?) -> FlutterError? {
+        self.eventSink = nil
+        print("[MpvPlayerPlugin] Event stream disconnected")
+        return nil
+    }
+
+    // MARK: - FlutterPlugin Method Handler
+
+    func handle(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
+        switch call.method {
+        case "initialize":
+            handleInitialize(result: result)
+
+        case "dispose":
+            handleDispose(result: result)
+
+        case "setProperty":
+            handleSetProperty(call: call, result: result)
+
+        case "getProperty":
+            handleGetProperty(call: call, result: result)
+
+        case "observeProperty":
+            handleObserveProperty(call: call, result: result)
+
+        case "command":
+            handleCommand(call: call, result: result)
+
+        case "setVisible":
+            handleSetVisible(call: call, result: result)
+
+        case "isInitialized":
+            result(playerCore?.isInitialized ?? false)
+
+        default:
+            result(FlutterMethodNotImplemented)
+        }
+    }
+
+    // MARK: - Method Handlers
+
+    private func handleInitialize(result: @escaping FlutterResult) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else {
+                result(FlutterError(code: "ERROR", message: "Plugin deallocated", details: nil))
+                return
+            }
+
+            // Check if already initialized
+            if self.playerCore?.isInitialized == true {
+                print("[MpvPlayerPlugin] Already initialized")
+                result(true)
+                return
+            }
+
+            // Find the Flutter window
+            guard let (window, _, _) = self.findFlutterWindow() else {
+                print("[MpvPlayerPlugin] Failed to find Flutter window")
+                result(FlutterError(code: "NO_WINDOW", message: "Could not find Flutter window", details: nil))
+                return
+            }
+
+            // Create and initialize player core
+            let core = MpvPlayerCore()
+            core.delegate = self
+
+            guard core.initialize(in: window) else {
+                print("[MpvPlayerPlugin] Failed to initialize MPV")
+                result(FlutterError(code: "MPV_INIT_FAILED", message: "Failed to initialize MPV", details: nil))
+                return
+            }
+
+            self.playerCore = core
+
+            // Start hidden
+            core.setVisible(false)
+
+            print("[MpvPlayerPlugin] Initialized successfully")
+            result(true)
+        }
+    }
+
+    private func handleDispose(result: @escaping FlutterResult) {
+        DispatchQueue.main.async { [weak self] in
+            self?.playerCore?.dispose()
+            self?.playerCore = nil
+            print("[MpvPlayerPlugin] Disposed")
+            result(nil)
+        }
+    }
+
+    private func handleSetProperty(call: FlutterMethodCall, result: @escaping FlutterResult) {
+        guard let args = call.arguments as? [String: Any],
+              let name = args["name"] as? String,
+              let value = args["value"] as? String else {
+            result(FlutterError(code: "INVALID_ARGS", message: "Missing 'name' or 'value' argument", details: nil))
+            return
+        }
+
+        playerCore?.setProperty(name, value: value)
+        result(nil)
+    }
+
+    private func handleGetProperty(call: FlutterMethodCall, result: @escaping FlutterResult) {
+        guard let args = call.arguments as? [String: Any],
+              let name = args["name"] as? String else {
+            result(FlutterError(code: "INVALID_ARGS", message: "Missing 'name' argument", details: nil))
+            return
+        }
+
+        let value = playerCore?.getProperty(name)
+        result(value)
+    }
+
+    private func handleObserveProperty(call: FlutterMethodCall, result: @escaping FlutterResult) {
+        guard let args = call.arguments as? [String: Any],
+              let name = args["name"] as? String,
+              let format = args["format"] as? String else {
+            result(FlutterError(code: "INVALID_ARGS", message: "Missing 'name' or 'format' argument", details: nil))
+            return
+        }
+
+        playerCore?.observeProperty(name, format: format)
+        result(nil)
+    }
+
+    private func handleCommand(call: FlutterMethodCall, result: @escaping FlutterResult) {
+        guard let args = call.arguments as? [String: Any],
+              let commandArgs = args["args"] as? [String] else {
+            result(FlutterError(code: "INVALID_ARGS", message: "Missing 'args' argument", details: nil))
+            return
+        }
+
+        playerCore?.command(commandArgs)
+        result(nil)
+    }
+
+    private func handleSetVisible(call: FlutterMethodCall, result: @escaping FlutterResult) {
+        guard let args = call.arguments as? [String: Any],
+              let visible = args["visible"] as? Bool else {
+            result(FlutterError(code: "INVALID_ARGS", message: "Missing 'visible' argument", details: nil))
+            return
+        }
+
+        DispatchQueue.main.async { [weak self] in
+            self?.playerCore?.setVisible(visible)
+
+            // Update frame when becoming visible
+            if visible {
+                self?.playerCore?.updateFrame()
+            }
+
+            result(nil)
+        }
+    }
+
+    // MARK: - MpvPlayerDelegate
+
+    func onPropertyChange(name: String, value: Any?) {
+        guard let eventSink = eventSink else { return }
+
+        var event: [String: Any] = ["type": "property", "name": name]
+
+        if let value = value {
+            event["value"] = value
+        }
+
+        eventSink(event)
+    }
+
+    func onEvent(name: String, data: [String: Any]?) {
+        guard let eventSink = eventSink else { return }
+
+        var event: [String: Any] = ["type": "event", "name": name]
+        if let data = data {
+            event["data"] = data
+        }
+
+        eventSink(event)
+    }
+
+    // MARK: - Helpers
+
+    private func findFlutterWindow() -> (NSWindow, NSView, NSView)? {
+        for window in NSApplication.shared.windows {
+            if window is MainFlutterWindow,
+               let contentView = window.contentView,
+               let contentVC = window.contentViewController {
+                let flutterView = contentVC.view
+                return (window, contentView, flutterView)
+            }
+        }
+
+        // Fallback
+        for window in NSApplication.shared.windows {
+            if let contentView = window.contentView,
+               let contentVC = window.contentViewController {
+                let flutterView = contentVC.view
+                return (window, contentView, flutterView)
+            }
+        }
+
+        return nil
+    }
+}