diff options
Diffstat (limited to 'osdep/macOS_mpv_helper.swift')
| -rw-r--r-- | osdep/macOS_mpv_helper.swift | 255 |
1 files changed, 255 insertions, 0 deletions
diff --git a/osdep/macOS_mpv_helper.swift b/osdep/macOS_mpv_helper.swift new file mode 100644 index 0000000000..39be9cc8c7 --- /dev/null +++ b/osdep/macOS_mpv_helper.swift @@ -0,0 +1,255 @@ +/* + * This file is part of mpv. + * + * mpv is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * mpv is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with mpv. If not, see <http://www.gnu.org/licenses/>. + */ + +import Cocoa +import OpenGL.GL +import OpenGL.GL3 + +class MPVHelper: NSObject { + + var mpvHandle: OpaquePointer? + var mpvGLCBContext: OpaquePointer? + var mpvLog: OpaquePointer? + var inputContext: OpaquePointer? + var mpctx: UnsafeMutablePointer<MPContext>? + + init(_ mpv: OpaquePointer) { + super.init() + mpvHandle = mpv + mpvLog = mp_log_new(UnsafeMutablePointer<MPContext>(mpvHandle), + mp_client_get_log(mpvHandle), "cocoacb") + mpctx = UnsafeMutablePointer<MPContext>(mp_client_get_core(mpvHandle)) + inputContext = mpctx!.pointee.input + + mpv_observe_property(mpvHandle, 0, "ontop", MPV_FORMAT_FLAG) + mpv_observe_property(mpvHandle, 0, "border", MPV_FORMAT_FLAG) + mpv_observe_property(mpvHandle, 0, "keepaspect-window", MPV_FORMAT_FLAG) + } + + func setGLCB() { + if mpvHandle == nil { + sendError("No mpv handle available.") + exit(1) + } + mpvGLCBContext = OpaquePointer(mp_get_sub_api2(mpvHandle, MPV_SUB_API_OPENGL_CB, false)) + if mpvGLCBContext == nil { + sendError("libmpv does not have the opengl-cb sub-API.") + exit(1) + } + } + + func initGLCB() { + if mpvGLCBContext == nil { + setGLCB() + } + if mpv_opengl_cb_init_gl(mpvGLCBContext, nil, getProcAddress, nil) < 0 { + sendError("GL init has failed.") + exit(1) + } + } + + let getProcAddress: mpv_opengl_cb_get_proc_address_fn = { + (ctx: UnsafeMutableRawPointer?, name: UnsafePointer<Int8>?) -> UnsafeMutableRawPointer? in + let symbol: CFString = CFStringCreateWithCString( + kCFAllocatorDefault, name, kCFStringEncodingASCII) + let indentifier = CFBundleGetBundleWithIdentifier("com.apple.opengl" as CFString) + let addr = CFBundleGetFunctionPointerForName(indentifier, symbol) + + if symbol as String == "glFlush" { + return glDummyPtr() + } + + return addr + } + + func setGLCBUpdateCallback(_ callback: @escaping mpv_opengl_cb_update_fn, context object: AnyObject) { + if mpvGLCBContext == nil { + sendWarning("Init mpv opengl-cb first.") + } else { + mpv_opengl_cb_set_update_callback(mpvGLCBContext, callback, MPVHelper.bridge(obj: object)) + } + } + + func setGLCBControlCallback(_ callback: @escaping mpv_opengl_cb_control_fn, context object: AnyObject) { + if mpvGLCBContext == nil { + sendWarning("Init mpv opengl-cb first.") + } else { + mp_client_set_control_callback(mpvGLCBContext, callback, MPVHelper.bridge(obj: object)) + } + } + + func reportGLCBFlip() { + if mpvGLCBContext == nil { return } + mpv_opengl_cb_report_flip(mpvGLCBContext, 0) + } + + func drawGLCB(_ surface: NSSize) { + if mpvGLCBContext != nil { + var i: GLint = 0 + glGetIntegerv(GLenum(GL_DRAW_FRAMEBUFFER_BINDING), &i) + + mpv_opengl_cb_draw(mpvGLCBContext, i, Int32(surface.width), Int32(-surface.height)) + } else { + glClearColor(0, 0, 0, 1) + glClear(GLbitfield(GL_COLOR_BUFFER_BIT)) + } + } + + func setGLCBICCProfile(_ profile: NSColorSpace) { + if mpvGLCBContext == nil { return } + var iccData = profile.iccProfileData + iccData!.withUnsafeMutableBytes { (u8Ptr: UnsafeMutablePointer<UInt8>) in + let icc = bstrdup(nil, bstr(start: u8Ptr, len: iccData!.count)) + mp_client_set_icc_profile(mpvGLCBContext, icc) + } + } + + func setGLCBLux(_ lux: Int) { + if mpvGLCBContext == nil { return } + mp_client_set_ambient_lux(mpvGLCBContext, Int32(lux)) + } + + func command(_ cmd: String) { + if mpvHandle == nil { return } + mpv_command_string(mpvHandle, cmd) + } + + func commandAsync(_ cmd: [String?], id: UInt64 = 1) { + if mpvHandle == nil { return } + var mCmd = cmd + mCmd.append(nil) + var cargs = mCmd.map { $0.flatMap { UnsafePointer<Int8>(strdup($0)) } } + mpv_command_async(mpvHandle, id, &cargs) + for ptr in cargs { free(UnsafeMutablePointer(mutating: ptr)) } + } + + func getBoolProperty(_ name: String) -> Bool { + if mpvHandle == nil { return false } + var value = Int32() + mpv_get_property(mpvHandle, name, MPV_FORMAT_FLAG, &value) + return value > 0 + } + + func getIntProperty(_ name: String) -> Int { + if mpvHandle == nil { return 0 } + var value = Int64() + mpv_get_property(mpvHandle, name, MPV_FORMAT_INT64, &value) + return Int(value) + } + + func getStringProperty(_ name: String) -> String? { + if mpvHandle == nil { return nil } + let value = mpv_get_property_string(mpvHandle, name) + let str = value == nil ? nil : String(cString: value!) + mpv_free(value) + return str + } + + func canBeDraggedAt(_ pos: NSPoint) -> Bool { + if inputContext == nil { return false } + let canDrag = !mp_input_test_dragging(inputContext!, Int32(pos.x), Int32(pos.y)) + return canDrag + } + + func setMousePosition(_ pos: NSPoint) { + if inputContext == nil { return } + mp_input_set_mouse_pos(inputContext!, Int32(pos.x), Int32(pos.y)) + } + + func putAxis(_ mpkey: Int32, delta: Double) { + if inputContext == nil { return } + mp_input_put_wheel(inputContext!, mpkey, delta) + } + + func sendVerbose(_ msg: String) { + send(message: msg, type: MSGL_V) + } + + func sendInfo(_ msg: String) { + send(message: msg, type: MSGL_INFO) + } + + func sendWarning(_ msg: String) { + send(message: msg, type: MSGL_WARN) + } + + func sendError(_ msg: String) { + send(message: msg, type: MSGL_ERR) + } + + func send(message msg: String, type t: Int) { + if mpvLog == nil { + sendFallback(message: msg, type: t) + } else { + let args: [CVarArg] = [ (msg as NSString).utf8String! ] + mp_msg_va(mpvLog, Int32(t), "%s\n", getVaList(args)) + } + } + + func sendFallback(message msg: String, type t: Int) { + var level = "\u{001B}" + switch t { + case MSGL_V: + level += "[0;30m[VERBOSE]" + case MSGL_INFO: + level += "[0;30m[INFO]" + case MSGL_WARN: + level += "[0;33m" + case MSGL_ERR: + level += "[0;31m" + default: + level += "[0;30m" + } + + print("\(level)[osx/cocoacb] \(msg)\u{001B}[0;30m") + } + + func deinitGLCB() { + mpv_opengl_cb_set_update_callback(mpvGLCBContext, nil, nil) + mp_client_set_control_callback(mpvGLCBContext, nil, nil) + mpv_opengl_cb_uninit_gl(mpvGLCBContext) + mpvGLCBContext = nil + } + + func deinitMPV() { + mpvHandle = nil + mpvLog = nil + inputContext = nil + mpctx = nil + } + + // (__bridge void*) + class func bridge<T: AnyObject>(obj: T) -> UnsafeMutableRawPointer { + return UnsafeMutableRawPointer(Unmanaged.passUnretained(obj).toOpaque()) + } + + // (__bridge T*) + class func bridge<T: AnyObject>(ptr: UnsafeRawPointer) -> T { + return Unmanaged<T>.fromOpaque(ptr).takeUnretainedValue() + } + + // *(char **) MPV_FORMAT_STRING on mpv_event_property + class func mpvStringArrayToString(_ obj: UnsafeMutableRawPointer) -> String? { + let cstr = UnsafeMutablePointer<UnsafeMutablePointer<Int8>>(OpaquePointer(obj)) + return String(cString: cstr[0]) + } + + // MPV_FORMAT_FLAG + class func mpvFlagToBool(_ obj: UnsafeMutableRawPointer) -> Bool? { + return UnsafePointer<Bool>(OpaquePointer(obj))?.pointee + } +} |