-

-

mpvnet/Addon.cs

@@ -0,0 +1,64 @@
+/**
+ *mpv.net
+ *Copyright(C) 2017 stax76
+ *
+ *This program is free software: you can redistribute it and/or modify
+ *it under the terms of the GNU General Public License as published by
+ *the Free Software Foundation, either version 3 of the License, or
+ *(at your option) any later version.
+ *
+ *This program 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 General Public License for more details.
+ *
+ *You should have received a copy of the GNU General Public License
+ *along with this program. If not, see http://www.gnu.org/licenses/.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.Composition;
+using System.ComponentModel.Composition.Hosting;
+using System.IO;
+using System.Windows.Forms;
+
+// MEF (Managed Extension Framework)
+
+namespace mpvnet
+{
+    public class Addon
+    {
+        [ImportMany]
+        public IEnumerable<IAddon> Addons = null;
+
+        private readonly CompositionContainer CompositionContainer;
+
+        public Addon()
+        {
+            AggregateCatalog catalog = new AggregateCatalog();
+
+            string dir = Application.StartupPath + "\\Addons";
+
+            if (Directory.Exists(dir))
+                foreach (string i in Directory.GetDirectories(dir))
+                    catalog.Catalogs.Add(new DirectoryCatalog(i, "*Addon.dll"));
+
+            dir = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\mpv\\Addons";
+
+            if (Directory.Exists(dir))
+                foreach (string i in Directory.GetDirectories(dir))
+                    catalog.Catalogs.Add(new DirectoryCatalog(i, "*Addon.dll"));
+
+            if (catalog.Catalogs.Count > 0)
+            {
+                CompositionContainer = new CompositionContainer(catalog);
+                CompositionContainer.ComposeParts(this);
+            }
+        }
+    }
+
+    public interface IAddon
+    {
+    }
+}

mpvnet/App.config

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+    <startup> 
+        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7"/>
+    </startup>
+</configuration>

mpvnet/MainForm.Designer.cs

@@ -0,0 +1,61 @@
+namespace mpvnet
+{
+    partial class MainForm
+    {
+        /// <summary>
+        /// Required designer variable.
+        /// </summary>
+        private System.ComponentModel.IContainer components = null;
+
+        /// <summary>
+        /// Clean up any resources being used.
+        /// </summary>
+        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing && (components != null))
+            {
+                components.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        #region Windows Form Designer generated code
+
+        /// <summary>
+        /// Required method for Designer support - do not modify
+        /// the contents of this method with the code editor.
+        /// </summary>
+        private void InitializeComponent()
+        {
+            this.components = new System.ComponentModel.Container();
+            System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(MainForm));
+            this.Timer = new System.Windows.Forms.Timer(this.components);
+            this.SuspendLayout();
+            // 
+            // Timer
+            // 
+            this.Timer.Enabled = true;
+            this.Timer.Interval = 1000;
+            this.Timer.Tick += new System.EventHandler(this.Timer_Tick);
+            // 
+            // MainForm
+            // 
+            this.AllowDrop = true;
+            this.AutoScaleDimensions = new System.Drawing.SizeF(19F, 37F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.BackColor = System.Drawing.Color.Black;
+            this.ClientSize = new System.Drawing.Size(1517, 951);
+            this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon")));
+            this.Name = "MainForm";
+            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
+            this.Text = "mpv.net";
+            this.ResumeLayout(false);
+
+        }
+
+        #endregion
+
+        private System.Windows.Forms.Timer Timer;
+    }
+}

mpvnet/MainForm.cs

@@ -0,0 +1,284 @@
+/**
+ *mpv.net
+ *Copyright(C) 2017 stax76
+ *
+ *This program is free software: you can redistribute it and/or modify
+ *it under the terms of the GNU General Public License as published by
+ *the Free Software Foundation, either version 3 of the License, or
+ *(at your option) any later version.
+ *
+ *This program 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 General Public License for more details.
+ *
+ *You should have received a copy of the GNU General Public License
+ *along with this program. If not, see http://www.gnu.org/licenses/.
+ */
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using System.Runtime.InteropServices;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows.Forms;
+
+namespace mpvnet
+{
+    public partial class MainForm : Form
+    {
+        public static MainForm Instance { get; set; }
+        public static IntPtr Hwnd;
+
+        private Point LastCursorPosChanged;
+        private int LastCursorChangedTickCount;
+
+        public ContextMenuEx Menu;
+
+        public MainForm()
+        {
+            try
+            {
+                Application.ThreadException += Application_ThreadException;
+                InitializeComponent();
+                Instance = this;
+                Hwnd = Handle;
+                mpv.Init();
+                mpv.ObserveBoolProp("fullscreen", MpvChangeFullscreen);
+                mpv.AfterShutdown += Mpv_AfterShutdown;
+                mpv.FileLoaded += Mpv_FileLoaded;
+                mpv.VideoSizeChanged += Mpv_VideoSizeChanged;
+
+                Menu = new ContextMenuEx();
+                ContextMenu = Menu;
+                ContextMenu.MenuItems.Add("About mpv.net", About);
+            }
+            catch (Exception e)
+            {
+                HandleException(e);
+            }
+        }
+
+        private void Application_ThreadException(object sender, ThreadExceptionEventArgs e)
+        {
+            HandleException(e.Exception);
+        }
+
+        void HandleException(Exception e)
+        {
+            MessageBox.Show(e.ToString(), "mpv.net Exception", MessageBoxButtons.OK, MessageBoxIcon.Error);
+        }
+
+        private void About(object sender, EventArgs e)
+        {
+            mpv.Command("show-text", Application.ProductName + " v" + Application.ProductVersion.ToString() +
+                "\nCopyright (c) 2017 stax76\nGPL License", "5000");
+        }
+
+        private void Mpv_VideoSizeChanged()
+        {
+            BeginInvoke(new Action(() => SetFormPosSize()));
+        }
+
+        private void Mpv_FileLoaded()
+        {
+            BeginInvoke(new Action(() => Text = mpv.GetStringProp("filename") + " - mpv.net"));
+        }
+
+        private void Mpv_AfterShutdown() => Invoke(new Action(() => Close()));
+
+        public bool IsFullscreen
+        {
+            get { return WindowState == FormWindowState.Maximized; }
+        }
+
+        void MpvChangeFullscreen(bool value)
+        {
+            BeginInvoke(new Action(() => ChangeFullscreen(value)));
+        }
+
+        void ChangeFullscreen(bool value)
+        {
+            if (value)
+            {
+                FormBorderStyle = FormBorderStyle.None;
+                WindowState = FormWindowState.Maximized;
+            }
+            else
+            {
+                WindowState = FormWindowState.Normal;
+                FormBorderStyle = FormBorderStyle.Sizable;
+            }
+        }
+
+        protected override void WndProc(ref Message m)
+        {
+            switch (m.Msg)
+            {
+                case 0x0201: // WM_LBUTTONDOWN
+                case 0x0202: // WM_LBUTTONUP
+                case 0x0100: // WM_KEYDOWN
+                case 0x0101: // WM_KEYUP
+                case 0x020A: // WM_MOUSEWHEEL
+                    if (mpv.MpvWindowHandle != IntPtr.Zero)
+                        Native.SendMessage(mpv.MpvWindowHandle, m.Msg, m.WParam, m.LParam);
+                    break;
+                case 0x203: // Native.WM.LBUTTONDBLCLK
+                    if (!IsMouseInOSC())
+                        mpv.CommandString("cycle fullscreen");
+                    break;
+                case 0x0214: // WM_SIZING
+                    var rc = Marshal.PtrToStructure<Native.RECT>(m.LParam);
+                    var r = rc;
+                    subtract_window_borders(Handle, ref r);
+                    int c_w = r.Right - r.Left, c_h = r.Bottom - r.Top;
+                    float aspect = mpv.VideoSize.Width / (float)mpv.VideoSize.Height;
+                    int d_w = (int)(c_h * aspect - c_w);
+                    int d_h = (int)(c_w / aspect - c_h);
+                    int[] d_corners = { d_w, d_h, -d_w, -d_h };
+                    int[] corners = { rc.Left, rc.Top, rc.Right, rc.Bottom };
+                    int corner = get_resize_border(m.WParam.ToInt32());
+
+                    if (corner >= 0)
+                        corners[corner] -= d_corners[corner];
+
+                    Marshal.StructureToPtr<Native.RECT>(new Native.RECT(corners[0], corners[1], corners[2], corners[3]), m.LParam, false);
+                    m.Result = new IntPtr(1);
+                    return;
+            }
+
+            base.WndProc(ref m);
+        }
+
+        static int get_resize_border(int v)
+        {
+            switch (v)
+            {
+                case 1 /* WMSZ_LEFT */       : return 3;
+                case 3 /* WMSZ_TOP */        : return 2;
+                case 2 /* WMSZ_RIGHT */      : return 3;
+                case 6 /* WMSZ_BOTTOM */     : return 2;
+                case 4 /* WMSZ_TOPLEFT */    : return 1;
+                case 5 /* WMSZ_TOPRIGHT */   : return 1;
+                case 7 /* WMSZ_BOTTOMLEFT */ : return 3;
+                case 8 /* WMSZ_BOTTOMRIGHT */: return 3;
+                default: return -1;
+            }
+        }
+
+        static void subtract_window_borders(IntPtr hwnd, ref Native.RECT rc)
+        {
+            var b = new Native.RECT(0, 0, 0, 0);
+            add_window_borders(hwnd, ref b);
+            rc.Left -= b.Left;
+            rc.Top -= b.Top;
+            rc.Right -= b.Right;
+            rc.Bottom -= b.Bottom;
+        }
+
+        static void add_window_borders(IntPtr hwnd, ref Native.RECT rc)
+        {
+            Native.AdjustWindowRect(ref rc, (uint)Native.GetWindowLongPtrW(hwnd, -16 /* GWL_STYLE */), false);
+        }
+
+        void SetFormPosSize()
+        {
+            if (IsFullscreen) return;
+            var wa = Screen.GetWorkingArea(this);
+            int h = (int)(wa.Height * 0.6);
+            int w = (int)(h * mpv.VideoSize.Width / (float)mpv.VideoSize.Height);
+            Point middlePos = new Point(Left + Width / 2, Top + Height / 2);
+            var r = new Native.RECT(new Rectangle(0, 0, w, h));
+            add_window_borders(Handle, ref r);
+            int l = middlePos.X - r.Width / 2;
+            int t = middlePos.Y - r.Height / 2;
+            if (l < 0) l = 0;
+            if (t < 0) t = 0;
+            if (l + r.Width > wa.Width ) l = wa.Width - r.Width;
+            if (t + r.Height > wa.Height ) t = wa.Height - r.Height;
+            Native.SetWindowPos(Handle, IntPtr.Zero /* HWND_TOP */, l, t, r.Width, r.Height, 4 /* SWP_NOZORDER */);
+        }
+
+        protected override void OnDragEnter(DragEventArgs e)
+        {
+            base.OnDragEnter(e);
+
+            if (e.Data.GetDataPresent(DataFormats.FileDrop))
+                e.Effect = DragDropEffects.Copy;
+        }
+
+        protected override void OnDragDrop(DragEventArgs e)
+        {
+            base.OnDragDrop(e);
+
+            if (e.Data.GetDataPresent(DataFormats.FileDrop))
+            {
+                int count = mpv.GetIntProp("playlist-count");
+                string[] files = e.Data.GetData(DataFormats.FileDrop) as String[];
+
+                foreach (string file in files)
+                    mpv.Command("loadfile", file, "append");
+
+                mpv.SetIntProp("playlist-pos", count);
+
+                for (int i = 0; i < count; i++)
+                    mpv.Command("playlist-remove", "0");         
+
+                mpv.LoadFolder();
+            }
+        }
+
+        protected override void OnMouseDown(MouseEventArgs e)
+        {
+            base.OnMouseDown(e);
+
+            // window-dragging
+            if (WindowState == FormWindowState.Normal &&
+                e.Button == MouseButtons.Left &&
+                e.Y < ClientSize.Height * 0.9)
+            {
+                var HTCAPTION = new IntPtr(2);
+                Native.ReleaseCapture();
+                Native.PostMessage(Handle, 0xA1 /* WM_NCLBUTTONDOWN */, HTCAPTION, IntPtr.Zero);
+            }
+        }
+
+        protected override void OnMouseMove(MouseEventArgs e)
+        {
+            base.OnMouseMove(e);
+
+            // send mouse command to make OSC show
+            mpv.CommandString($"mouse {e.X} {e.Y}");
+
+            if (CursorHelp.IsPosDifferent(LastCursorPosChanged))
+                CursorHelp.Show();
+        }
+
+        protected override void OnFormClosed(FormClosedEventArgs e)
+        {
+            base.OnFormClosed(e);
+            mpv.Terminate();
+        }
+
+        bool IsMouseInOSC()
+        {
+            return PointToClient(Control.MousePosition).Y > ClientSize.Height * 0.9;
+        }
+
+        private void Timer_Tick(object sender, EventArgs e)
+        {
+            if (CursorHelp.IsPosDifferent(LastCursorPosChanged))
+            {
+                LastCursorPosChanged = Control.MousePosition;
+                LastCursorChangedTickCount = Environment.TickCount;
+            }
+            else if (Environment.TickCount - LastCursorChangedTickCount > 1500 &&
+                !IsMouseInOSC() && ClientRectangle.Contains(PointToClient(MousePosition)) &&
+                Form.ActiveForm == this && !Menu.Visible)
+            {
+                CursorHelp.Hide();
+            }
+        }
+    }
+}

mpvnet/Misc.cs

@@ -0,0 +1,17 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace mpvnet
+{
+    public class StringLogicalComparer : IComparer, IComparer<string>
+    {
+        [DllImport("shlwapi.dll", CharSet = CharSet.Unicode)]
+        public static extern int StrCmpLogical(string x, string y);
+
+        int IComparer_Compare(object x, object y) => StrCmpLogical(x.ToString(), y.ToString());
+        int IComparer.Compare(object x, object y) => IComparer_Compare(x, y);
+        int IComparerOfString_Compare(string x, string y) => StrCmpLogical(x, y);
+        int IComparer<string>.Compare(string x, string y) => IComparerOfString_Compare(x, y);
+    }
+}

mpvnet/Native.cs

@@ -0,0 +1,99 @@
+/**
+ *mpv.net
+ *Copyright(C) 2017 stax76
+ *
+ *This program is free software: you can redistribute it and/or modify
+ *it under the terms of the GNU General Public License as published by
+ *the Free Software Foundation, either version 3 of the License, or
+ *(at your option) any later version.
+ *
+ *This program 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 General Public License for more details.
+ *
+ *You should have received a copy of the GNU General Public License
+ *along with this program. If not, see http://www.gnu.org/licenses/.
+ */
+
+using System;
+using System.Drawing;
+using System.Runtime.InteropServices;
+
+namespace mpvnet
+{
+    public class Native
+    {
+        [DllImport("kernel32.dll")]
+        public static extern IntPtr LoadLibrary(string dllToLoad);
+
+        [DllImport("user32.dll", CharSet = CharSet.Unicode)]
+        public static extern IntPtr FindWindowEx(IntPtr parentHandle, IntPtr childAfter, string lclassName, string windowTitle);
+
+        [DllImport("user32.dll", CharSet = CharSet.Auto)]
+        public static extern string SendMessage(IntPtr hWnd, int msg, IntPtr wParam, IntPtr lParam);
+
+        [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Auto)]
+        public static extern bool PostMessage(IntPtr hWnd, int Msg, IntPtr wParam, IntPtr lParam);
+
+        [DllImport("user32.dll", SetLastError = true)]
+        public static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int x, int y, int cx, int cy, uint uFlags);
+
+        [DllImport("user32.dll")]
+        public static extern void ReleaseCapture();
+
+        [DllImport("user32.dll")]
+        public static extern bool AdjustWindowRect(ref RECT lpRect, uint dwStyle, bool bMenu);
+
+        [DllImport("user32.dll")]
+        public static extern IntPtr GetWindowLongPtrW(IntPtr hWnd, int nIndex);
+
+        [DllImport("user32.dll", SetLastError = true)]
+        public static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int X, int Y, int cx, int cy, int uFlags);
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct RECT
+        {
+            public int Left;
+            public int Top;
+            public int Right;
+            public int Bottom;
+
+            public RECT(Rectangle r)
+            {
+                Left = r.Left;
+                Top = r.Top;
+                Right = r.Right;
+                Bottom = r.Bottom;
+            }
+
+            public RECT(int left, int top, int right, int bottom)
+            {
+                Left = left;
+                Top = top;
+                Right = right;
+                Bottom = bottom;
+            }
+
+            public Rectangle ToRectangle()
+            {
+                return Rectangle.FromLTRB(Left, Top, Right, Bottom);
+            }
+
+            public Size Size
+            {
+                get { return new Size(Right - Left, Bottom - Top); }
+            }
+
+            public int Width
+            {
+                get { return Right - Left; }
+            }
+
+            public int Height
+            {
+                get { return Bottom - Top; }
+            }
+        }
+    }
+}

mpvnet/Program.cs

@@ -0,0 +1,34 @@
+/**
+ *mpv.net
+ *Copyright(C) 2017 stax76
+ *
+ *This program is free software: you can redistribute it and/or modify
+ *it under the terms of the GNU General Public License as published by
+ *the Free Software Foundation, either version 3 of the License, or
+ *(at your option) any later version.
+ *
+ *This program 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 General Public License for more details.
+ *
+ *You should have received a copy of the GNU General Public License
+ *along with this program. If not, see http://www.gnu.org/licenses/.
+ */
+
+using System;
+using System.Windows.Forms;
+
+namespace mpvnet
+{
+    static class Program
+    {
+        [STAThread]
+        static void Main()
+        {
+            Application.EnableVisualStyles();
+            Application.SetCompatibleTextRenderingDefault(false);
+            Application.Run(new MainForm());
+        }
+    }
+}

mpvnet/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("mpv.net")]
+[assembly: AssemblyDescription("mpv/libmpv based player with pure mpv experience")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("mpv.net")]
+[assembly: AssemblyCopyright("Copyright © 2017 stax76")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("1751f378-8edf-4b62-be6d-304c7c287089")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("0.1.0.0")]
+[assembly: AssemblyFileVersion("0.1.0.0")]

mpvnet/Properties/Resources.Designer.cs

@@ -0,0 +1,63 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30319.42000
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace mpvnet.Properties {
+    using System;
+    
+    
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "15.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class Resources {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal Resources() {
+        }
+        
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("mpvnet.Properties.Resources", typeof(Resources).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+    }
+}

mpvnet/Properties/Resources.resx

@@ -0,0 +1,117 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>

mpvnet/Properties/Settings.Designer.cs

@@ -0,0 +1,26 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30319.42000
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace mpvnet.Properties {
+    
+    
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "15.3.0.0")]
+    internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase {
+        
+        private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
+        
+        public static Settings Default {
+            get {
+                return defaultInstance;
+            }
+        }
+    }
+}

mpvnet/Properties/Settings.settings

@@ -0,0 +1,7 @@
+<?xml version='1.0' encoding='utf-8'?>
+<SettingsFile xmlns="http://schemas.microsoft.com/VisualStudio/2004/01/settings" CurrentProfile="(Default)">
+  <Profiles>
+    <Profile Name="(Default)" />
+  </Profiles>
+  <Settings />
+</SettingsFile>

mpvnet/StringExtensions.cs

@@ -0,0 +1,46 @@
+/**
+ *mpv.net
+ *Copyright(C) 2017 stax76
+ *
+ *This program is free software: you can redistribute it and/or modify
+ *it under the terms of the GNU General Public License as published by
+ *the Free Software Foundation, either version 3 of the License, or
+ *(at your option) any later version.
+ *
+ *This program 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 General Public License for more details.
+ *
+ *You should have received a copy of the GNU General Public License
+ *along with this program. If not, see http://www.gnu.org/licenses/.
+ */
+
+using System.IO;
+
+namespace mpvnet
+{
+    public static class ExtensionMethods
+    {
+        public static string Ext(this string instance)
+        {
+            if (string.IsNullOrEmpty(instance))
+                return "";
+
+            string ext = Path.GetExtension(instance);
+
+            if (ext == "")
+                return "";
+
+            return ext.ToLowerInvariant().Substring(1);
+        }
+
+        public static string ExtFull(this string instance)
+        {
+            if (string.IsNullOrEmpty(instance))
+                return "";
+
+            return Path.GetExtension(instance).ToLowerInvariant();
+        }
+    }
+}

mpvnet/UI.cs

@@ -0,0 +1,79 @@
+/**
+ *mpv.net
+ *Copyright(C) 2017 stax76
+ *
+ *This program is free software: you can redistribute it and/or modify
+ *it under the terms of the GNU General Public License as published by
+ *the Free Software Foundation, either version 3 of the License, or
+ *(at your option) any later version.
+ *
+ *This program 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 General Public License for more details.
+ *
+ *You should have received a copy of the GNU General Public License
+ *along with this program. If not, see http://www.gnu.org/licenses/.
+ */
+
+using System;
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace mpvnet
+{
+    public class CursorHelp
+    {
+        static bool IsVisible = true;
+
+        public static void Show()
+        {
+            if (!IsVisible)
+            {
+                Cursor.Show();
+                IsVisible = true;
+            }
+        }
+
+        public static void Hide()
+        {
+            if (IsVisible)
+            {
+                Cursor.Hide();
+                IsVisible = false;
+            }
+        }
+
+        public static bool IsPosDifferent(Point screenPos)
+        {
+            return
+                Math.Abs(screenPos.X - Control.MousePosition.X) > 10 ||
+                Math.Abs(screenPos.Y - Control.MousePosition.Y) > 10;
+        }
+    }
+
+    public static class MsgBox
+    {
+        public static void MsgInfo(string text)
+        {
+            MessageBox.Show(text, Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Information);
+        }
+    }
+
+    public class ContextMenuEx : ContextMenu
+    {
+        public bool Visible { get ; set; }
+
+        protected override void OnCollapse(EventArgs e)
+        {
+            base.OnCollapse(e);
+            Visible = false;
+        }
+
+        protected override void OnPopup(EventArgs e)
+        {
+            base.OnPopup(e);
+            Visible = true;
+        }
+    }
+}

mpvnet/app.manifest

@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="utf-8"?>
+<assembly
+  manifestVersion="1.0"
+  xmlns="urn:schemas-microsoft-com:asm.v1"
+  xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
+  <assemblyIdentity version="1.0.0.0" name="MyApplication.app"/>
+  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
+    <security>
+      <requestedPrivileges xmlns="urn:schemas-microsoft-com:asm.v3">
+        <requestedExecutionLevel level="asInvoker" uiAccess="false" />
+      </requestedPrivileges>
+    </security>
+  </trustInfo>
+  <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
+    <application>
+      <!-- Windows 7 -->
+      <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}" />
+      <!-- Windows 8 -->
+      <supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}" />
+      <!-- Windows 8.1 -->
+      <supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}" />
+      <!-- Windows 10 -->
+      <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" />
+    </application>
+  </compatibility>
+  <application>
+    <windowsSettings>
+      <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true</dpiAware>
+    </windowsSettings>
+  </application>
+  <dependency>
+    <dependentAssembly>
+      <assemblyIdentity
+          type="win32"
+          name="Microsoft.Windows.Common-Controls"
+          version="6.0.0.0"
+          processorArchitecture="*"
+          publicKeyToken="6595b64144ccf1df"
+          language="*"
+        />
+    </dependentAssembly>
+  </dependency>
+</assembly>

mpvnet/libmpv.cs

@@ -0,0 +1,185 @@
+/**
+ *mpv.net
+ *Copyright(C) 2017 stax76
+ *
+ *This program is free software: you can redistribute it and/or modify
+ *it under the terms of the GNU General Public License as published by
+ *the Free Software Foundation, either version 3 of the License, or
+ *(at your option) any later version.
+ *
+ *This program 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 General Public License for more details.
+ *
+ *You should have received a copy of the GNU General Public License
+ *along with this program. If not, see http://www.gnu.org/licenses/.
+ */
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace mpvnet
+{
+    public class libmpv
+    {
+        [DllImport("mpv-1.dll", CallingConvention = CallingConvention.Cdecl)]
+        public static extern IntPtr mpv_create();
+
+        [DllImport("mpv-1.dll", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int mpv_initialize(IntPtr mpvHandle);
+
+        [DllImport("mpv-1.dll", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int mpv_command(IntPtr mpvHandle, IntPtr strings);
+
+        [DllImport("mpv-1.dll", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int mpv_command_string(IntPtr mpvHandle, [MarshalAs(UnmanagedType.LPUTF8Str)] string command);
+
+        [DllImport("mpv-1.dll", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int mpv_terminate_destroy(IntPtr mpvHandle);
+
+        [DllImport("mpv-1.dll", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int mpv_set_option(IntPtr mpvHandle, byte[] name, mpv_format format, ref long data);
+
+        [DllImport("mpv-1.dll", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int mpv_set_option_string(IntPtr mpvHandle, byte[] name, byte[] value);
+
+        [DllImport("mpv-1.dll", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int mpv_get_property(IntPtr mpvHandle, byte[] name, mpv_format format, ref IntPtr data);
+
+        [DllImport("mpv-1.dll", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int mpv_set_property(IntPtr mpvHandle, byte[] name, mpv_format format, ref byte[] data);
+
+        [DllImport("mpv-1.dll", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int mpv_set_property(IntPtr mpvHandle, byte[] name, mpv_format format, ref Int64 data);
+
+        [DllImport("mpv-1.dll", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int mpv_observe_property(
+            IntPtr mpvHandle,
+            UInt64 reply_userdata,
+            [MarshalAs(UnmanagedType.LPUTF8Str)] string name,
+            mpv_format format);
+
+        [DllImport("mpv-1.dll", CallingConvention = CallingConvention.Cdecl)]
+        public static extern int mpv_unobserve_property(IntPtr mpvHandle, UInt64 registered_reply_userdata);
+
+        [DllImport("mpv-1.dll", CallingConvention = CallingConvention.Cdecl)]
+        public static extern void mpv_free(IntPtr data);
+
+        [DllImport("mpv-1.dll", CallingConvention = CallingConvention.Cdecl)]
+        public static extern IntPtr mpv_wait_event(IntPtr mpvHandle, double timeout);
+
+        public enum mpv_error
+        {
+            MPV_ERROR_SUCCESS = 0,
+            MPV_ERROR_EVENT_QUEUE_FULL = -1,
+            MPV_ERROR_NOMEM = -2,
+            MPV_ERROR_UNINITIALIZED = -3,
+            MPV_ERROR_INVALID_PARAMETER = -4,
+            MPV_ERROR_OPTION_NOT_FOUND = -5,
+            MPV_ERROR_OPTION_FORMAT = -6,
+            MPV_ERROR_OPTION_ERROR = -7,
+            MPV_ERROR_PROPERTY_NOT_FOUND = -8,
+            MPV_ERROR_PROPERTY_FORMAT = -9,
+            MPV_ERROR_PROPERTY_UNAVAILABLE = -10,
+            MPV_ERROR_PROPERTY_ERROR = -11,
+            MPV_ERROR_COMMAND = -12,
+            MPV_ERROR_LOADING_FAILED = -13,
+            MPV_ERROR_AO_INIT_FAILED = -14,
+            MPV_ERROR_VO_INIT_FAILED = -15,
+            MPV_ERROR_NOTHING_TO_PLAY = -16,
+            MPV_ERROR_UNKNOWN_FORMAT = -17,
+            MPV_ERROR_UNSUPPORTED = -18,
+            MPV_ERROR_NOT_IMPLEMENTED = -19,
+            MPV_ERROR_GENERIC = -20
+        }
+
+        public enum mpv_event_id
+        {
+            MPV_EVENT_NONE = 0,
+            MPV_EVENT_SHUTDOWN = 1,
+            MPV_EVENT_LOG_MESSAGE = 2,
+            MPV_EVENT_GET_PROPERTY_REPLY = 3,
+            MPV_EVENT_SET_PROPERTY_REPLY = 4,
+            MPV_EVENT_COMMAND_REPLY = 5,
+            MPV_EVENT_START_FILE = 6,
+            MPV_EVENT_END_FILE = 7,
+            MPV_EVENT_FILE_LOADED = 8,
+            MPV_EVENT_TRACKS_CHANGED = 9,
+            MPV_EVENT_TRACK_SWITCHED = 10,
+            MPV_EVENT_IDLE = 11,
+            MPV_EVENT_PAUSE = 12,
+            MPV_EVENT_UNPAUSE = 13,
+            MPV_EVENT_TICK = 14,
+            MPV_EVENT_SCRIPT_INPUT_DISPATCH = 15,
+            MPV_EVENT_CLIENT_MESSAGE = 16,
+            MPV_EVENT_VIDEO_RECONFIG = 17,
+            MPV_EVENT_AUDIO_RECONFIG = 18,
+            MPV_EVENT_METADATA_UPDATE = 19,
+            MPV_EVENT_SEEK = 20,
+            MPV_EVENT_PLAYBACK_RESTART = 21,
+            MPV_EVENT_PROPERTY_CHANGE = 22,
+            MPV_EVENT_CHAPTER_CHANGE = 23,
+            MPV_EVENT_QUEUE_OVERFLOW = 24
+        }
+
+        public enum mpv_format
+        {
+            MPV_FORMAT_NONE = 0,
+            MPV_FORMAT_STRING = 1,
+            MPV_FORMAT_OSD_STRING = 2,
+            MPV_FORMAT_FLAG = 3,
+            MPV_FORMAT_INT64 = 4,
+            MPV_FORMAT_DOUBLE = 5,
+            MPV_FORMAT_NODE = 6,
+            MPV_FORMAT_NODE_ARRAY = 7,
+            MPV_FORMAT_NODE_MAP = 8,
+            MPV_FORMAT_BYTE_ARRAY = 9
+        }
+
+        public enum mpv_log_level
+        {
+            MPV_LOG_LEVEL_NONE  = 0,
+            MPV_LOG_LEVEL_FATAL = 10,
+            MPV_LOG_LEVEL_ERROR = 20,
+            MPV_LOG_LEVEL_WARN  = 30,
+            MPV_LOG_LEVEL_INFO  = 40,
+            MPV_LOG_LEVEL_V     = 50,
+            MPV_LOG_LEVEL_DEBUG = 60,
+            MPV_LOG_LEVEL_TRACE = 70,
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct mpv_event_log_message
+        {
+            public string prefix;
+            public string level;
+            public string text;
+            public mpv_log_level log_level;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct mpv_event
+        {
+            public mpv_event_id event_id;
+            public int error;
+            public UInt64 reply_userdata;
+            public IntPtr data;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct mpv_event_client_message
+        {
+            public int num_args;
+            public IntPtr args;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct mpv_event_property
+        {
+            [MarshalAs(UnmanagedType.LPUTF8Str)] public string name;
+            public mpv_format format;
+            public IntPtr data;
+        }
+    }
+}

mpvnet/mpv.cs

@@ -0,0 +1,316 @@
+/**
+ *mpv.net
+ *Copyright(C) 2017 stax76
+ *
+ *This program is free software: you can redistribute it and/or modify
+ *it under the terms of the GNU General Public License as published by
+ *the Free Software Foundation, either version 3 of the License, or
+ *(at your option) any later version.
+ *
+ *This program 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 General Public License for more details.
+ *
+ *You should have received a copy of the GNU General Public License
+ *along with this program. If not, see http://www.gnu.org/licenses/.
+ */
+
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+
+using static mpvnet.libmpv;
+using static mpvnet.Native;
+using System.Drawing;
+
+using static mpvnet.MsgBox;
+
+namespace mpvnet
+{
+    public delegate void MpvBoolPropChangeHandler(string propName, bool value);
+
+    public class mpv
+    {
+        public static event Action<string[]> ClientMessage;
+        public static event Action Shutdown;
+        public static event Action AfterShutdown;
+        public static event Action FileLoaded;
+        public static event Action PlaybackRestart;
+        public static event Action VideoSizeChanged;
+
+        public static IntPtr MpvHandle;
+        public static IntPtr MpvWindowHandle;
+        public static Addon Addon;
+        public static List<Action<bool>> BoolPropChangeActions = new List<Action<bool>>();
+
+        public static Size VideoSize;
+
+        public static void Init()
+        {
+            LoadLibrary("mpv-1.dll");
+            MpvHandle = mpv_create();
+            SetStringProp("hwdec", "auto");
+            SetIntProp("input-ar-delay", 500);
+            SetIntProp("input-ar-rate", 20);
+            SetStringProp("input-default-bindings", "yes");
+            SetStringProp("opengl-backend", "angle");
+            SetIntProp("osd-duration", 3000);
+            SetStringProp("osd-playing-msg", "'${filename}'");
+            SetStringProp("profile", "opengl-hq");
+            SetStringProp("screenshot-directory", "~~desktop/");
+            SetStringProp("vo", "opengl");
+            SetIntProp("volume", 50);
+            SetStringProp("keep-open", "always");
+            SetStringProp("keep-open-pause", "no");
+            SetStringProp("osc", "yes");
+            SetStringProp("config", "yes");
+            SetStringProp("wid", MainForm.Hwnd.ToString());
+            SetStringProp("force-window", "yes");
+            mpv_initialize(MpvHandle);
+            ProcessCommandLine();
+            Task.Run(() => { Addon = new Addon(); });
+            Task.Run(() => { EventLoop(); });
+        }
+
+        public static void EventLoop()
+        {
+            while (true)
+            {
+                IntPtr ptr = mpv_wait_event(MpvHandle, -1);
+                mpv_event evt = (mpv_event)Marshal.PtrToStructure(ptr, typeof(mpv_event));
+                Debug.WriteLine(evt.event_id);
+
+                if (MpvWindowHandle == IntPtr.Zero)
+                    MpvWindowHandle = FindWindowEx(MainForm.Hwnd, IntPtr.Zero, "mpv", null);
+
+                switch (evt.event_id)
+                {
+                    case mpv_event_id.MPV_EVENT_SHUTDOWN:
+                        Shutdown?.Invoke();
+                        AfterShutdown?.Invoke();
+                        return;
+                    case mpv_event_id.MPV_EVENT_FILE_LOADED:
+                        FileLoaded?.Invoke();
+                        break;
+                    case mpv_event_id.MPV_EVENT_PLAYBACK_RESTART:
+                        PlaybackRestart?.Invoke();
+                        var s = new Size(GetIntProp("dwidth"), GetIntProp("dheight"));
+
+                        if (VideoSize != s)
+                        {
+                            VideoSize = s;
+                            VideoSizeChanged?.Invoke();
+                        }
+
+                        break;
+                    case mpv_event_id.MPV_EVENT_CLIENT_MESSAGE:
+                        if (ClientMessage != null)
+                        {
+                            var client_messageData = (mpv_event_client_message)Marshal.PtrToStructure(evt.data, typeof(mpv_event_client_message));
+                            ClientMessage?.Invoke(NativeUtf8StrArray2ManagedStrArray(client_messageData.args, client_messageData.num_args));
+                        }
+
+                        break;
+                    case mpv_event_id.MPV_EVENT_PROPERTY_CHANGE:
+                        var eventData = (mpv_event_property)Marshal.PtrToStructure(evt.data, typeof(mpv_event_property));
+
+                        if (eventData.format == mpv_format.MPV_FORMAT_FLAG)
+                            foreach (var action in BoolPropChangeActions)
+                                action.Invoke(Marshal.PtrToStructure<int>(eventData.data) == 1);
+
+                        break;
+                }
+            }
+        }
+
+        public static void Command(params string[] args)
+        {
+            if (MpvHandle == IntPtr.Zero)
+                return;
+
+            IntPtr[] byteArrayPointers;
+            var mainPtr = AllocateUtf8IntPtrArrayWithSentinel(args, out byteArrayPointers);
+            int err = mpv_command(MpvHandle, mainPtr);
+
+            if (err < 0)
+                throw new Exception($"{(mpv_error)err}");
+
+            foreach (var ptr in byteArrayPointers)
+                Marshal.FreeHGlobal(ptr);
+
+            Marshal.FreeHGlobal(mainPtr);
+        }
+
+        public static void CommandString(string command)
+        {
+            if (MpvHandle == IntPtr.Zero)
+                return;
+
+            int err = mpv_command_string(MpvHandle, command);
+
+            if (err < 0)
+                throw new Exception($"{(mpv_error)err}");
+        }
+
+        public static void SetStringProp(string name, string value, bool throwException = true)
+        {
+            var bytes = GetUtf8Bytes(value);
+            int err = mpv_set_property(MpvHandle, GetUtf8Bytes(name), mpv_format.MPV_FORMAT_STRING, ref bytes);
+
+            if (err < 0 && throwException)
+                throw new Exception($"{name}: {(mpv_error)err}");
+        }
+
+        public static string GetStringProp(string name)
+        {
+            var lpBuffer = IntPtr.Zero;
+            int err = mpv_get_property(MpvHandle, GetUtf8Bytes(name), mpv_format.MPV_FORMAT_STRING, ref lpBuffer);
+
+            if (err < 0)
+            {
+                throw new Exception($"{name}: {(mpv_error)err}");
+            }
+            else
+            {
+                var ret = Marshal.PtrToStringAnsi(lpBuffer);
+                mpv_free(lpBuffer);
+                return ret;
+            }
+        }
+
+        public static int GetIntProp(string name)
+        {
+            var lpBuffer = IntPtr.Zero;
+            int err = mpv_get_property(MpvHandle, GetUtf8Bytes(name), mpv_format.MPV_FORMAT_INT64, ref lpBuffer);
+
+            if (err < 0)
+                throw new Exception($"{(mpv_error)err}");
+            else
+                return lpBuffer.ToInt32();
+        }
+
+        public static void SetIntProp(string name, int value)
+        {
+            Int64 val = value;
+            int err = mpv_set_property(MpvHandle, GetUtf8Bytes(name), mpv_format.MPV_FORMAT_INT64, ref val);
+
+            if (err < 0)
+                throw new Exception($"{(mpv_error)err}");
+        }
+
+        public static void ObserveBoolProp(string name, Action<bool> action)
+        {
+            BoolPropChangeActions.Add(action);
+            int err = mpv_observe_property(MpvHandle, (ulong)action.GetHashCode(), name, mpv_format.MPV_FORMAT_FLAG);
+
+            if (err < 0)
+                throw new Exception($"{(mpv_error)err}");
+        }
+
+        public static void UnobserveBoolProp(string name, Action<bool> action)
+        {
+            BoolPropChangeActions.Remove(action);
+            int err = mpv_unobserve_property(MpvHandle, (ulong)action.GetHashCode());
+
+            if (err < 0)
+                throw new Exception($"{(mpv_error)err}");
+        }
+
+        public static void ProcessCommandLine()
+        {
+            var args = Environment.GetCommandLineArgs().Skip(1);
+
+            foreach (string i in args)
+                if (!i.StartsWith("--") && File.Exists(i))
+                    mpv.Command("loadfile", i, "append");
+
+            mpv.SetStringProp("playlist-pos", "0", false);
+
+            foreach (string i in args)
+            {
+                if (i.StartsWith("--"))
+                {
+                    if (i.Contains("="))
+                    {
+                        string left = i.Substring(2, i.IndexOf("=") - 2);
+                        string right = i.Substring(left.Length + 3);
+                        mpv.SetStringProp(left, right);
+                    }
+                    else
+                        mpv.SetStringProp(i.Substring(2), "yes");
+                }
+            }
+
+            LoadFolder();
+        }
+
+        public static void LoadFolder()
+        {
+            if (GetIntProp("playlist-count") == 1)
+            {
+                string[] types = "264 265 3gp aac ac3 avc avi avs bmp divx dts dtshd dtshr dtsma eac3 evo flac flv h264 h265 hevc hvc jpg jpeg m2t m2ts m2v m4a m4v mka mkv mlp mov mp2 mp3 mp4 mpa mpeg mpg mpv mts ogg ogm opus pcm png pva raw rmvb thd thd+ac3 true-hd truehd ts vdr vob vpy w64 wav webm wmv y4m".Split(' ');
+                string path = GetStringProp("path");
+                List<string> files = Directory.GetFiles(Path.GetDirectoryName(path)).ToList();
+                files = files.Where((file) => types.Contains(file.Ext())).ToList();
+                files.Sort(new StringLogicalComparer());
+                int index = files.IndexOf(path);
+                files.Remove(path);
+
+                foreach (string i in files)
+                    Command("loadfile", i, "append");
+
+                if (index > 0)
+                    Command("playlist-move", "0", (index + 1).ToString());
+            }
+        }
+
+        public static void Terminate() => libmpv.mpv_terminate_destroy(MpvHandle);
+
+        public static IntPtr AllocateUtf8IntPtrArrayWithSentinel(string[] arr, out IntPtr[] byteArrayPointers)
+        {
+            int numberOfStrings = arr.Length + 1; // add extra element for extra null pointer last (sentinel)
+            byteArrayPointers = new IntPtr[numberOfStrings];
+            IntPtr rootPointer = Marshal.AllocCoTaskMem(IntPtr.Size * numberOfStrings);
+
+            for (int index = 0; index < arr.Length; index++)
+            {
+                var bytes = GetUtf8Bytes(arr[index]);
+                IntPtr unmanagedPointer = Marshal.AllocHGlobal(bytes.Length);
+                Marshal.Copy(bytes, 0, unmanagedPointer, bytes.Length);
+                byteArrayPointers[index] = unmanagedPointer;
+            }
+
+            Marshal.Copy(byteArrayPointers, 0, rootPointer, numberOfStrings);
+            return rootPointer;
+        }
+
+        public static string[] NativeUtf8StrArray2ManagedStrArray(IntPtr pUnmanagedStringArray, int StringCount)
+        {
+            IntPtr[] pIntPtrArray = new IntPtr[StringCount];
+            string[] ManagedStringArray = new string[StringCount];
+            Marshal.Copy(pUnmanagedStringArray, pIntPtrArray, 0, StringCount);
+
+            for (int i = 0; i < StringCount; i++)
+                ManagedStringArray[i] = StringFromNativeUtf8(pIntPtrArray[i]);
+
+            return ManagedStringArray;
+        }
+
+        public static string StringFromNativeUtf8(IntPtr nativeUtf8)
+        {
+            int len = 0;
+            while (Marshal.ReadByte(nativeUtf8, len) != 0) ++len;
+            byte[] buffer = new byte[len];
+            Marshal.Copy(nativeUtf8, buffer, 0, buffer.Length);
+            return Encoding.UTF8.GetString(buffer);
+        }
+
+        public static byte[] GetUtf8Bytes(string s) => Encoding.UTF8.GetBytes(s + "\0");
+    }
+}

mpvnet/mpv.net.csproj

@@ -0,0 +1,159 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{1751F378-8EDF-4B62-BE6D-304C7C287089}</ProjectGuid>
+    <OutputType>WinExe</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>mpvnet</RootNamespace>
+    <AssemblyName>mpvnet</AssemblyName>
+    <TargetFrameworkVersion>v4.7</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
+    <TargetFrameworkProfile />
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup />
+  <PropertyGroup />
+  <PropertyGroup>
+    <StartupObject>mpvnet.Program</StartupObject>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x64\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <Prefer32Bit>true</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
+    <OutputPath>bin\x64\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <Prefer32Bit>true</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x86\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <Prefer32Bit>true</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">
+    <OutputPath>bin\x86\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <Prefer32Bit>true</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup />
+  <PropertyGroup />
+  <PropertyGroup />
+  <PropertyGroup />
+  <PropertyGroup />
+  <PropertyGroup />
+  <PropertyGroup />
+  <PropertyGroup />
+  <PropertyGroup>
+    <ApplicationIcon>mpv.ico</ApplicationIcon>
+  </PropertyGroup>
+  <PropertyGroup>
+    <ApplicationManifest>app.manifest</ApplicationManifest>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.ComponentModel.Composition" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Addon.cs" />
+    <Compile Include="libmpv.cs" />
+    <Compile Include="MainForm.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="MainForm.Designer.cs">
+      <DependentUpon>MainForm.cs</DependentUpon>
+    </Compile>
+    <Compile Include="Misc.cs" />
+    <Compile Include="mpv.cs" />
+    <Compile Include="Native.cs" />
+    <Compile Include="Program.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="StringExtensions.cs" />
+    <Compile Include="UI.cs" />
+    <EmbeddedResource Include="MainForm.resx">
+      <DependentUpon>MainForm.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Properties\Resources.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
+      <SubType>Designer</SubType>
+    </EmbeddedResource>
+    <Compile Include="Properties\Resources.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Resources.resx</DependentUpon>
+      <DesignTime>True</DesignTime>
+    </Compile>
+    <None Include="app.manifest" />
+    <None Include="Properties\Settings.settings">
+      <Generator>SettingsSingleFileGenerator</Generator>
+      <LastGenOutput>Settings.Designer.cs</LastGenOutput>
+    </None>
+    <Compile Include="Properties\Settings.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Settings.settings</DependentUpon>
+      <DesignTimeSharedInput>True</DesignTimeSharedInput>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="App.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="mpv.ico" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>