Mpv.NET

.NET video/media player based on mpv along with a wrapper for the C API.

Player Features

• Looping
• Auto-play
• Asynchronous seeking
• Change playback speed
• Simple setup and usage
• Logging from mpv
• Add separate audio track
• Playlist - Load, Next, Previous, Move, Remove, Shuffle or Clear
• Optional youtube-dl support to play videos from hundreds of video sites.
  • Change the desired video quality.

Notes:

• Very little documentation has been written for the C API wrapper. Consult client.h.
• The entirety of the mpv C API has not yet been implemented.

If you encounter any bugs or would like to see a feature added then please open an issue. Contributions are very welcome!

Download

This package is available via NuGet.

Prerequisites

To use the wrapper (and user control) you will need libmpv.

1. Download libmpv from https://mpv.srsfckn.biz/ (latest "Dev" build)
2. Extract "mpv-1.dll" from either the "i686" (32-bit) or "x86_64" (64-bit) folder into your project. (A "lib" folder in your project is common practice)
3. Include the DLL in your IDE and instruct your build system to copy the DLL to output.
   • In Visual Studio this can be achieved so:
     1. In your Solution Explorer click the "Show All Files" button at the top. (make sure you have the correct project selected)
     2. You should see the DLL show up, right click on it and select "Include In Project".
     3. Right click on the DLL and select "Properties", then change the value for "Copy to Output Directory" to "Copy Always".
4. Done!

If you wish to compile libmpv yourself, there is a guide available in the mpv repository.

Player

This player was designed to work on Windows and tested in WPF and WinForms. Not tested on other platforms.

To overlay controls over the top of the player please see this issue.

If you're looking for a media player UI, I'd recommend MediaPlayerUI.NET. :)

Initialisation

MpvPlayer provides 4 constructors:

1. MpvPlayer()
2. MpvPlayer(string libMpvPath)
3. MpvPlayer(IntPtr hwnd)
4. MpvPlayer(IntPtr hwnd, string libMpvPath)

Constructors #1 and #2 let mpv create it's own window and will not embed it.

Constructors #3 and #4 allow you to specify a hwnd parameter which should be the handle to the host control where you want to embed the player.

For the constructors where libMpvPath is not included, the player attempts to load libmpv from: (in order)

• LibMpvPath property
• "mpv-1.dll"
• "lib\mpv-1.dll"

WPF

Since WPF doesn't keep traditional handles to controls we will need to use a System.Windows.Forms.Control object (E.g. Panel or nearly any other WinForms control) to host the mpv instance.

First you will need to add a reference to System.Windows.Forms in your project:

• In Visual Studio this can be achieved so:
  • Right click "References" in your project and click "Add Reference".
  • Navigate to Assemblies, find System.Windows.Forms, make sure it's ticked and click "OK".

Next, you will need to reference the System.Windows.Forms namespace in XAML:

<Window ...
        xmlns:windowsForms="clr-namespace:System.Windows.Forms;assembly=System.Windows.Forms"
        ...>

Then create a WindowsFormsHost with a Panel from WinForms:

<WindowsFormsHost>
    <windowsForms:Panel x:Name="PlayerHost" />
</WindowsFormsHost>

In your .xaml.cs file create a field/property of type MpvPlayer and initialise it using one of the constructors outlined above.

In this example we called our Panel object PlayerHost so for the hwnd parameter in the constructor you would pass in PlayerHost.Handle (see below)

player = new MpvPlayer(PlayerHost.Handle);

See Mpv.NET.WPFExample project for a basic example.

WinForms

You can use any WinForms control, just pass the Handle property to the MpvPlayer constructor and you're done! Easy.

See Mpv.NET.WinFormsExample project for a basic example.

API

This "API" is a wrapper around the mpv C API defined in client.h and is utilised by the player.

Mpv

Simplest way to create an instance of the mpv .NET API and load libmpv:

// Relative path to the DLL.
var dllPath = @"lib\mpv-1.dll";

using (var mpv = new Mpv(dllPath))
{
    // code
}

This will provide a friendly interface to the mpv C API and start an event loop which will raise events accordingly.

MpvFunctions

If you are looking for a more direct approach to the C API you can create an instance of MpvFunctions which allows you to execute the loaded delegates directly:

var dllPath = @"lib\mpv-1.dll";

using (var mpvFunctions = new MpvFunctions(dllPath))
{
    // code
}

Be aware, this method does not raise events and an event loop would have to be manually implemented.

MpvEventLoop

If you are looking that start an event loop you will need to create an instance of MpvFunctions, create and initialise mpv, create an instance of MpvEventLoop and start it:

var dllPath = @"lib\mpv-1.dll";

// Create an instance of MpvFunctions.
var functions = new MpvFunctions(dllPath)

// Create mpv
var handle = functions.Create();

// Initialise mpv
functions.Initialise(handle);
    
// Create an instance of MpvEventLoop, passing in a callback argument
// which will be invoked when an event comes in.
using (var eventLoop = new MpvEventLoop(callback, handle, functions))
{
    // Start the event loop.
    eventLoop.Start();
}

The code above does not contain any error checking, most of the mpv functions return an MpvError which indicates whether an error has occured.

Licensing

The libmpv C API specifically is licensed under ICS, this means that a wrapper such as this can be licensed under MIT.

The rest of libmpv is licensed under GPLv2 by default, which means that any work utilising this wrapper in conjunction with libmpv is subject to GPLv2, unless libmpv is compiled using LGPL.

In simple terms, once you use the "libmpv" files you downloaded with your application it must be licensed under GPLv2.

See here for more information.