switch to LibVlc

QuickLook.Plugin/QuickLook.Plugin.VideoViewer/ViewerPanel.xaml.cs

@@ -16,19 +16,30 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 using System;
+using System.ComponentModel;
 using System.Diagnostics;
-using System.Windows;
+using System.Runtime.CompilerServices;
 using System.Windows.Controls;
 using System.Windows.Input;
+using Meta.Vlc;
+using Meta.Vlc.Interop.Media;
+using QuickLook.Annotations;
+using MediaState = Meta.Vlc.Interop.Media.MediaState;
 
 namespace QuickLook.Plugin.VideoViewer
 {
     /// <summary>
     ///     Interaction logic for UserControl1.xaml
     /// </summary>
-    public partial class ViewerPanel : UserControl, IDisposable
+    public partial class ViewerPanel : UserControl, IDisposable, INotifyPropertyChanged
     {
         private readonly ContextObject _context;
+        private string _coverArt;
+        private bool _hasAudio;
+        private bool _hasEnded;
+        private bool _hasVideo;
+        private bool _isMuted;
+        private bool _isPlaying;
 
         private bool _wasPlaying;
 
@@ -36,6 +47,9 @@ namespace QuickLook.Plugin.VideoViewer
         {
             InitializeComponent();
 
+            mediaElement.PropertyChanged += PlayerPropertyChanged;
+            mediaElement.StateChanged += PlayerStateChanged;
+
             _context = context;
 
             buttonPlayPause.MouseLeftButtonUp += TogglePlayPause;
@@ -44,14 +58,14 @@ namespace QuickLook.Plugin.VideoViewer
             //    mediaElement.IsMuted = false;
             //    buttonMute.Visibility = Visibility.Collapsed;
             //};
-            buttonMute.MouseLeftButtonUp += (sender, e) => mediaElement.IsMuted = !mediaElement.IsMuted;
-            buttonStop.MouseLeftButtonUp += (sender, e) => mediaElement.Stop();
+            buttonMute.MouseLeftButtonUp += (sender, e) => IsMuted = !IsMuted;
+            buttonStop.MouseLeftButtonUp += PlayerStop;
             buttonBackward.MouseLeftButtonUp += (sender, e) => Seek(TimeSpan.FromSeconds(-10));
             buttonForward.MouseLeftButtonUp += (sender, e) => Seek(TimeSpan.FromSeconds(10));
 
             sliderProgress.PreviewMouseDown += (sender, e) =>
             {
-                _wasPlaying = mediaElement.IsPlaying;
+                _wasPlaying = mediaElement.VlcMediaPlayer.IsPlaying;
                 mediaElement.Pause();
             };
             sliderProgress.PreviewMouseUp += (sender, e) =>
@@ -59,7 +73,7 @@ namespace QuickLook.Plugin.VideoViewer
                 if (_wasPlaying) mediaElement.Play();
             };
 
-            mediaElement.MediaFailed += ShowErrorNotification;
+            mediaElement.VlcMediaPlayer.EncounteredError += ShowErrorNotification;
             /*mediaElement.MediaEnded += (s, e) =>
             {
                 if (mediaElement.IsOpen)
@@ -70,14 +84,87 @@ namespace QuickLook.Plugin.VideoViewer
                     }
             };*/
 
-            PreviewMouseWheel += (sender, e) => ChangeVolume((double) e.Delta / 120 / 50);
+            PreviewMouseWheel += (sender, e) => ChangeVolume((double) e.Delta / 120 * 2);
         }
 
+        public bool IsMuted
+        {
+            get => _isMuted;
+            set
+            {
+                if (value == _isMuted) return;
+                _isMuted = value;
+                mediaElement.IsMute = value;
+                OnPropertyChanged();
+            }
+        }
+
+        public bool HasEnded
+        {
+            get => _hasEnded;
+            private set
+            {
+                if (value == _hasEnded) return;
+                _hasEnded = value;
+                OnPropertyChanged();
+            }
+        }
+
+        public bool HasAudio
+        {
+            get => _hasAudio;
+            private set
+            {
+                if (value == _hasAudio) return;
+                _hasAudio = value;
+                OnPropertyChanged();
+            }
+        }
+
+        public bool HasVideo
+        {
+            get => _hasVideo;
+            private set
+            {
+                if (value == _hasVideo) return;
+                _hasVideo = value;
+                OnPropertyChanged();
+            }
+        }
+
+        public bool IsPlaying
+        {
+            get => _isPlaying;
+            private set
+            {
+                if (value == _isPlaying) return;
+                _isPlaying = value;
+                OnPropertyChanged();
+            }
+        }
+
+        public string CoverArt
+        {
+            get => _coverArt;
+            private set
+            {
+                if (value == _coverArt) return;
+                if (value == null) return;
+                _coverArt = value;
+                OnPropertyChanged();
+            }
+        }
+
+        public string LibVlcPath { get; } = VlcSettings.LibVlcPath;
+
+        public string[] VlcOption { get; } = VlcSettings.VlcOptions;
+
         public void Dispose()
         {
             try
             {
-                mediaElement?.Stop();
+                //if (mediaElement != null && !mediaElement.VlcMediaPlayer.CanPlay)
+                //    Thread.Sleep(200);
                 mediaElement?.Dispose();
             }
             catch (Exception e)
@@ -87,40 +174,98 @@ namespace QuickLook.Plugin.VideoViewer
             mediaElement = null;
         }
 
+        public event PropertyChangedEventHandler PropertyChanged;
+
+        private void PlayerStop(object sender, MouseButtonEventArgs e)
+        {
+            HasEnded = false;
+            IsPlaying = false;
+            mediaElement.Position = 0;
+            mediaElement.Stop();
+        }
+
+        private void PlayerPropertyChanged(object sender, PropertyChangedEventArgs e)
+        {
+            var prop = e.PropertyName;
+
+            switch (prop)
+            {
+                case nameof(mediaElement.IsMute):
+                    IsMuted = mediaElement.IsMute;
+                    break;
+            }
+        }
+
+        private void PlayerStateChanged(object sender, ObjectEventArgs<MediaState> e)
+        {
+            var state = e.Value;
+
+            switch (state)
+            {
+                case MediaState.Opening:
+                    HasVideo = mediaElement.VlcMediaPlayer.VideoTrackCount > 0;
+                    HasAudio = mediaElement.VlcMediaPlayer.AudioTrackCount > 0;
+                    CoverArt = mediaElement.VlcMediaPlayer.Media.GetMeta(
+                        MetaDataType.ArtworkUrl);
+                    break;
+                case MediaState.Playing:
+                    HasVideo = mediaElement.VlcMediaPlayer.VideoTrackCount > 0;
+                    HasAudio = mediaElement.VlcMediaPlayer.AudioTrackCount > 0;
+                    IsPlaying = true;
+                    break;
+                case MediaState.Paused:
+                    IsPlaying = false;
+                    break;
+                case MediaState.Ended:
+                    IsPlaying = false;
+                    HasEnded = true;
+                    break;
+                case MediaState.Error:
+                    ShowErrorNotification(sender, e);
+                    break;
+            }
+        }
+
         private void ChangeVolume(double delta)
         {
-            mediaElement.Volume += delta;
+            IsMuted = false;
+
+            var newVol = mediaElement.Volume + (int) delta;
+            newVol = Math.Max(newVol, 0);
+            newVol = Math.Min(newVol, 100);
+
+            mediaElement.Volume = newVol;
         }
 
         private void Seek(TimeSpan delta)
         {
-            _wasPlaying = mediaElement.IsPlaying;
+            _wasPlaying = mediaElement.VlcMediaPlayer.IsPlaying;
             mediaElement.Pause();
 
-            mediaElement.Position = mediaElement.Position + delta;
+            mediaElement.Time += delta;
 
             if (_wasPlaying) mediaElement.Play();
         }
 
         private void TogglePlayPause(object sender, MouseButtonEventArgs e)
         {
-            if (mediaElement.IsPlaying)
+            if (mediaElement.VlcMediaPlayer.IsPlaying)
             {
                 mediaElement.Pause();
             }
             else
             {
-                if (mediaElement.HasMediaEnded)
+                if (HasEnded)
                     mediaElement.Stop();
                 mediaElement.Play();
             }
         }
 
         [DebuggerNonUserCode]
-        private void ShowErrorNotification(object sender, ExceptionRoutedEventArgs exceptionRoutedEventArgs)
+        private void ShowErrorNotification(object sender, EventArgs e)
         {
             _context.ShowNotification("", "An error occurred while loading the video.");
-            mediaElement?.Close();
+            mediaElement?.Stop();
 
             Dispose();
 
@@ -130,8 +275,10 @@ namespace QuickLook.Plugin.VideoViewer
 
         public void LoadAndPlay(string path)
         {
-            mediaElement.Source = new Uri(path);
-            mediaElement.MediaOpened += (sender, e) => mediaElement.Volume = 0.2;
+            mediaElement.LoadMedia(path);
+            mediaElement.Volume = 50;
+
+            mediaElement.Play();
         }
 
         ~ViewerPanel()
@@ -139,5 +286,11 @@ namespace QuickLook.Plugin.VideoViewer
             GC.SuppressFinalize(this);
             Dispose();
         }
+
+        [NotifyPropertyChangedInvocator]
+        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
+        {
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+        }
     }
 }