Forums | NoesisGUI

((Noesis.Image)owner.Child).Source = pixels.TextureSource;

#if NOESIS
using Noesis;
#else
using System.Runtime.InteropServices;
#endif
using System;

namespace NoesisApp
{
    public class MPVMediaPlayer : MediaPlayer
    {
        private Texture texture;
        Pixels pixels;
        IntPtr mpvHandle;
        IntPtr mpvRenderContext;

        MPVMediaPlayer(MediaElement owner, Uri uri)
        {
            Console.WriteLine("MPVMediaPlayer: owner: " + owner.ToString() + ", uri: " + uri.ToString());

            // init mpv player
            mpvHandle = libmpv.mpv_create();
            if (mpvHandle == IntPtr.Zero)
            {
                throw new Exception("mpv_create");
            }

            // mpv properties/parameters
            libmpv.SetPropertyString(mpvHandle, "terminal", "yes");
            libmpv.SetPropertyString(mpvHandle, "msg-level", "all=v");
            libmpv.SetPropertyString(mpvHandle, "profile", "sw-fast");

            // mpv init
            libmpv.mpv_error err = libmpv.mpv_initialize(mpvHandle);
            if (err < 0)
            {
                throw new Exception("mpv_initialize error: " + libmpv.GetError(err));
            }

            IntPtr api = Marshal.StringToHGlobalAnsi("sw");
            libmpv.mpv_render_param[] renderParams = {
                new libmpv.mpv_render_param(libmpv.mpv_render_param_type.MPV_RENDER_PARAM_API_TYPE, api),
                new libmpv.mpv_render_param(libmpv.mpv_render_param_type.MPV_RENDER_PARAM_INVALID, IntPtr.Zero)
            };
            err = libmpv.mpv_render_context_create(out mpvRenderContext, mpvHandle, renderParams);
            if (err < 0)
            {
                throw new Exception("mpv_render_context_create error: " + libmpv.GetError(err));
            }
            Marshal.FreeHGlobal(api);

            // pixels data
            pixels = new Pixels((uint)owner.ActualWidth, (uint)owner.ActualHeight,
                new DynamicTextureSource((uint)owner.ActualWidth, (uint)owner.ActualHeight, TextureRender, this));

            // load media
            libmpv.CommandV(mpvHandle, "loadfile", "/" + uri.GetPath(), "replace");

            // TODO: handle RaiseMediaOpened
            ((Noesis.Image)owner.Child).Source = pixels.TextureSource;
            //RaiseMediaOpened();
        }

        ~MPVMediaPlayer()
        {
            Close();
        }

        public override void Close()
        {
            if (mpvRenderContext != IntPtr.Zero)
            {
                libmpv.mpv_render_context_free(mpvRenderContext);
                mpvRenderContext = IntPtr.Zero;
            }

            if (mpvHandle != IntPtr.Zero)
            {
                libmpv.mpv_destroy(mpvHandle);
                mpvHandle = IntPtr.Zero;
            }
        }

        public override uint Width
        {
            get { return !Stopped() ? (uint)libmpv.GetPropertyInt(mpvHandle, "width") : 0; }
        }

        public override uint Height
        {
            get { return !Stopped() ? (uint)libmpv.GetPropertyInt(mpvHandle, "height") : 0; }
        }

        public override bool CanPause
        {
            get { return true; }
        }

        public override bool HasAudio
        {
            get { return true; }
        }

        public override bool HasVideo
        {
            get { return true; }
        }

        public override float BufferingProgress
        {
            get { return 1; }
        }

        public override float DownloadProgress
        {
            get { return 1; }
        }

        public override double Duration
        {
            get { return !Stopped() ? libmpv.GetPropertyDouble(mpvHandle, "duration") : 0; }
        }

        public override double Position
        {
            get { return !Stopped() ? libmpv.GetPropertyDouble(mpvHandle, "playback-time") : 0; }
            set { if (!Stopped()) libmpv.Command(mpvHandle, "no-osd seek " + value.ToString()); }
        }

        public override float SpeedRatio
        {
            get { return !Stopped() ? (float)libmpv.GetPropertyDouble(mpvHandle, "speed") : 0; }
            set { if (!Stopped()) libmpv.Command(mpvHandle, "no-osd set speed " + value.ToString()); }
        }

        public override float Volume
        {
            get { return 0.5f; }
        }

        public override float Balance
        {
            get { return 0.5f; }
        }

        public override bool IsMuted
        {
            get { return false; }
        }

        public override bool ScrubbingEnabled
        {
            get { return false; }
        }

        public override void Play()
        {
            Console.WriteLine("MPVMediaPlayer: Play");
            if (!Stopped()) libmpv.Command(mpvHandle, "set pause no");
        }

        public override void Pause()
        {
            Console.WriteLine("MPVMediaPlayer: Pause");
            if (!Stopped()) libmpv.Command(mpvHandle, "set pause yes");
        }

        public override void Stop()
        {
            Console.WriteLine("MPVMediaPlayer: Stop");
            if (!Stopped()) libmpv.Command(mpvHandle, "stop");
        }

        public bool Stopped()
        {
            return mpvRenderContext == IntPtr.Zero || libmpv.GetPropertyBool(mpvHandle, "playback-abort");
        }

        public override ImageSource TextureSource
        {
            get
            {
                Console.WriteLine("MPVMediaPlayer: TextureSource");
                return pixels.TextureSource;
            }
        }

        public static MediaPlayer Create(MediaElement owner, Uri uri, object user)
        {
            return new MPVMediaPlayer(owner, uri);
        }

        private static Texture TextureRender(RenderDevice device, object user)
        {
            MPVMediaPlayer mediaPlayer = user as MPVMediaPlayer;
            return mediaPlayer.GetTexture(device);
        }

        unsafe private Texture GetTexture(RenderDevice device)
        {
            if (texture == null || pixels.Width != (uint)Width || pixels.Height != (uint)Height)
            {
                Console.WriteLine("MpvMediaPlayer: resizing pixels (" + Width + " x " + Height + ")");
                pixels.Resize((uint)Width, (uint)Height);
                texture = device.CreateTexture("mpv", pixels.Width, pixels.Height, 1, TextureFormat.RGBA8, IntPtr.Zero);
            }

            libmpv.mpv_render_context_flag flags = libmpv.mpv_render_context_update(mpvRenderContext);
            if (flags.HasFlag(libmpv.mpv_render_context_flag.MPV_RENDER_UPDATE_FRAME))
            {
                lock (pixels)
                {
                    fixed (byte* data = pixels.Data)
                    {
                        long p = pixels.Pitch;
                        IntPtr pitch = (IntPtr)(long*)&p;
                        int[] s = { (int)pixels.Width, (int)pixels.Height };
                        fixed (int* size = s)
                        {
                            libmpv.mpv_render_param[] renderParams = {
                                new libmpv.mpv_render_param(libmpv.mpv_render_param_type.MPV_RENDER_PARAM_SW_SIZE, new IntPtr(size)),
                                new libmpv.mpv_render_param(libmpv.mpv_render_param_type.MPV_RENDER_PARAM_SW_FORMAT, pixels.FormatPtr),
                                new libmpv.mpv_render_param(libmpv.mpv_render_param_type.MPV_RENDER_PARAM_SW_STRIDE, pitch),
                                new libmpv.mpv_render_param(libmpv.mpv_render_param_type.MPV_RENDER_PARAM_SW_POINTER, (IntPtr)data),
                                new libmpv.mpv_render_param(libmpv.mpv_render_param_type.MPV_RENDER_PARAM_INVALID, IntPtr.Zero)
                            };

                            libmpv.mpv_error err = libmpv.mpv_render_context_render(mpvRenderContext, renderParams);
                            if (err < 0)
                            {
                                throw new Exception("mpv_render_context_render error: " + libmpv.GetError(err));
                            }
                        }

                        device.UpdateTexture(texture, 0, 0, 0, pixels.Width, pixels.Height, (IntPtr)data);
                    }
                }
            }

            return texture;
        }

        private class Pixels
        {
            public Pixels(uint w, uint h, DynamicTextureSource tex)
            {
                FormatPtr = Marshal.StringToHGlobalAnsi("rgba");
                TextureSource = tex;
                Resize(w, h);
            }

            ~Pixels()
            {
                Marshal.FreeHGlobal(FormatPtr);
            }

            public void Resize(uint w, uint h)
            {
                Width = (uint)w;
                Height = (uint)h;
                Pitch = w * Bpp;
                Data = new byte[w * h * Bpp];
                TextureSource.Resize(w, h);
            }

            public uint Width;
            public uint Height;
            public uint Bpp { get => 4; }
            public long Pitch;
            public byte[] Data;
            public int Length { get => Data.Length; }
            public IntPtr FormatPtr;
            public DynamicTextureSource TextureSource;
        }
    }
}