Updating to v3.3.9 / v1.1.13

Ensures decoders are paused on Player's pause (was causing rendering issues)
Fixes Pan Zoom In/Out to respect aspect ratio
Fixes and Improves Recording to start and stop more accurate and support audio only (moved from demuxers to decoders)
Fixes AudioDemuxer to seek within queue
Fixes a rare dead lock during seeking and re-syncing (after open/download) subtitiles

Controls.WPF: Adds subtitles shadow for better visibility
Controls.WPF: Fixes IsRecording bindings
Plugins.BitSwarm: Updating to v2.4.2 which fixes a critical issue that sometimes it wouldn't start after pause

Author: SuRGeoNix

FlyleafLib.Controls.WPF/Flyleaf.xaml

@@ -65,7 +65,7 @@
                                             <Binding Path="Player.BitRate"/>
                                             <Binding Path="VideoInfo.BitRate"/>
                                             <Binding Path="AudioInfo.BitRate"/>
-                                            <Binding Path="VideoDemuxer.IsRecording"/>
+                                            <Binding Path="Player.IsRecording"/>
                                             <Binding Path="VideoInfo.DroppedFrames"/>
                                             <Binding Path="GPUUsage"/>
                                         </MultiBinding>

FlyleafLib.Controls.WPF/Flyleaf.xaml.cs

@@ -623,7 +623,7 @@ private void ToggleRecordAction(object obj = null)
         {
             if (!Player.CanPlay) return;
 
-            if (Player.decoder.VideoDemuxer.IsRecording)
+            if (Player.IsRecording)
                 Player.StopRecording();
             else
             {

FlyleafLib.Controls.WPF/FlyleafLib.Controls.WPF.csproj

@@ -4,7 +4,7 @@
     <TargetFrameworks>net5.0-windows;net472</TargetFrameworks>
 	<UseWindowsForms>true</UseWindowsForms>
     <UseWPF>true</UseWPF>
-    <Version>1.1.12</Version>
+    <Version>1.1.13</Version>
     <Authors>SuRGeoNix</Authors>
     <Copyright>SuRGeoNix © 2021</Copyright>
     <PackageLicenseExpression>LGPL-3.0-or-later</PackageLicenseExpression>
@@ -13,7 +13,10 @@
     <PackageIconUrl />
     <PackageTags>flyleaf flyleaflib video audio media player element control</PackageTags>
     <Description>WPF Media Player Control/Element (based on FlyleafLib)</Description>
-    <PackageReleaseNotes>Adds Color Themes (based on MaterialDesigninXaml)</PackageReleaseNotes>
+    <PackageReleaseNotes>
+		Adds subtitles shadow for better visibility
+		Fixes IsRecording bindings
+	</PackageReleaseNotes>
   </PropertyGroup>
 
   <ItemGroup>

FlyleafLib.Controls.WPF/MainDictionary.xaml

@@ -314,7 +314,7 @@
                 </MenuItem.ItemContainerStyle>
             </MenuItem>
             <MenuItem Header="HW Acceleration" IsCheckable="True" IsChecked="{Binding VideoConfig.VideoAcceleration}"/>
-            <MenuItem Header="Record" IsCheckable="True" IsChecked="{Binding Player.IsRecording}" Command="{Binding ToggleRecord}"/>
+            <MenuItem Header="Record" IsCheckable="True" IsChecked="{Binding Player.IsRecording, Mode=OneWay}" Command="{Binding ToggleRecord}"/>
             <MenuItem Header="{Binding PlayerConfig.Speed}" HeaderStringFormat="Speed ({0})">
                 <MenuItem Header=" x 1"   CommandParameter="1" Command="{Binding SetPlaybackSpeed}"/>
                 <MenuItem Header=" x 2"   CommandParameter="2" Command="{Binding SetPlaybackSpeed}"/>

FlyleafLib/FlyleafLib.csproj

@@ -8,7 +8,7 @@
 	<PackageIconUrl />
 	<RepositoryUrl></RepositoryUrl>
 	<Description>Media Player .NET Library for WPF/WinForms (based on FFmpeg/DirectX)</Description>
-	<Version>3.3.8</Version>
+	<Version>3.3.9</Version>
 	<Authors>SuRGeoNix</Authors>
 	<Copyright>SuRGeoNix © 2021</Copyright>
 	<PackageLicenseExpression>LGPL-3.0-or-later</PackageLicenseExpression>
@@ -17,12 +17,11 @@
 	<IncludeSymbols>true</IncludeSymbols>
     <SymbolPackageFormat>snupkg</SymbolPackageFormat>
     <PackageReleaseNotes>
-		Improves interrupts implementation
-		Adds draining support to VideoDecoder.GetNextFrame
-		Initializes AudioPlayer early to allow changing volume/mute (before opening any input)
-		Ensures rendering is disabled on initialization
-		Fixes critical issues with interrupts (could stop the demuxers/decoders)
-		Fixes critical race condition issues with RunThreadBase (could prevent demuxers/decoders from starting)
+		Ensures decoders are paused on Player's pause (was causing rendering issues)
+		Fixes Pan Zoom In/Out to respect aspect ratio
+		Fixes and Improves Recording to start and stop more accurate and support audio only
+		Fixes AudioDemuxer to seek within queue
+		Fixes a rare dead lock during seeking and re-syncing (after open/download) subtitiles
 	</PackageReleaseNotes>
   </PropertyGroup>
 

FlyleafLib/FlyleafLib.xml

@@ -84,6 +84,9 @@ public DecoderContext(Config config = null, Control control = null, int uniqueId
             VideoDecoder        = new VideoDecoder(Config, control, UniqueId);
             AudioDecoder        = new AudioDecoder(Config, UniqueId, VideoDecoder);
             SubtitlesDecoder    = new SubtitlesDecoder(Config, UniqueId);
+
+            VideoDecoder.recCompleted = RecordCompleted;
+            AudioDecoder.recCompleted = RecordCompleted;
         }
         public void Initialize()
         {
@@ -626,6 +629,7 @@ public int Seek(long ms = -1, bool foreward = false)
 
             if (ms == -1) ms = GetCurTimeMs();
 
+            // Review decoder locks (lockAction should be added to avoid dead locks with flush mainly before lockCodecCtx)
             lock (VideoDecoder.lockCodecCtx)
             lock (AudioDecoder.lockCodecCtx)
             lock (SubtitlesDecoder.lockCodecCtx)
@@ -657,7 +661,7 @@ public int Seek(long ms = -1, bool foreward = false)
             {
                 AudioDecoder.Pause();
                 AudioDecoder.Flush();
-                AudioDemuxer.PauseOnQueueFull = true; // Pause() will cause corrupted packets which causes av_read_frame to EOF
+                AudioDemuxer.PauseOnQueueFull = true;
                 RequiresResync = true;
             }
 
@@ -673,44 +677,55 @@ public int Seek(long ms = -1, bool foreward = false)
         }
         public int SeekAudio(long ms = -1, bool foreward = false)
         {
-            int ret = -1;
+            int ret = 0;
 
-            if (AudioDemuxer.Disposed || AudioDecoder.OnVideoDemuxer || !Config.Audio.Enabled) return ret;
+            if (AudioDemuxer.Disposed || AudioDecoder.OnVideoDemuxer || !Config.Audio.Enabled) return -1;
 
             if (ms == -1) ms = GetCurTimeMs();
 
+            long seekTimestamp = CalcSeekTimestamp(AudioDemuxer, ms, ref foreward);
+
+            lock (AudioDecoder.lockActions)
             lock (AudioDecoder.lockCodecCtx)
             {
-                ret = AudioDemuxer.Seek(CalcSeekTimestamp(AudioDemuxer, ms, ref foreward), foreward);
-                AudioDecoder.Flush();
-            }
+                lock (AudioDemuxer.lockActions)
+                    if (AudioDemuxer.SeekInQueue(seekTimestamp, foreward) != 0)
+                        ret = AudioDemuxer.Seek(seekTimestamp, foreward);
 
-            if (VideoDecoder.IsRunning)
-            {
-                AudioDemuxer.Start();
-                AudioDecoder.Start();
+                AudioDecoder.Flush();
+                if (VideoDecoder.IsRunning)
+                {
+                    AudioDemuxer.Start();
+                    AudioDecoder.Start();
+                }
             }
 
             return ret;
         }
         public int SeekSubtitles(long ms = -1, bool foreward = false)
         {
-            int ret = -1;
+            int ret = 0;
 
-            if (SubtitlesDemuxer.Disposed || SubtitlesDecoder.OnVideoDemuxer || !Config.Subtitles.Enabled) return ret;
+            if (SubtitlesDemuxer.Disposed || SubtitlesDecoder.OnVideoDemuxer || !Config.Subtitles.Enabled) return -1;
 
             if (ms == -1) ms = GetCurTimeMs();
 
+            long seekTimestamp = CalcSeekTimestamp(SubtitlesDemuxer, ms, ref foreward);
+
+            lock (SubtitlesDecoder.lockActions)
             lock (SubtitlesDecoder.lockCodecCtx)
             {
-                ret = SubtitlesDemuxer.Seek(CalcSeekTimestamp(SubtitlesDemuxer, ms, ref foreward), foreward);
-                SubtitlesDecoder.Flush();
-            }
+                // Currently disabled as it will fail to seek within the queue the most of the times
+                //lock (SubtitlesDemuxer.lockActions)
+                    //if (SubtitlesDemuxer.SeekInQueue(seekTimestamp, foreward) != 0)
+                ret = SubtitlesDemuxer.Seek(seekTimestamp, foreward);
 
-            if (VideoDecoder.IsRunning)
-            {
-                SubtitlesDemuxer.Start();
-                SubtitlesDecoder.Start();
+                SubtitlesDecoder.Flush();
+                if (VideoDecoder.IsRunning)
+                {
+                    SubtitlesDemuxer.Start();
+                    SubtitlesDecoder.Start();
+                }
             }
 
             return ret;
@@ -994,58 +1009,64 @@ public void PrintStats()
 
         #region Recorder
         Remuxer Recorder = new Remuxer();
+        public event EventHandler RecordingCompleted;
         public bool IsRecording
         {
-            get => VideoDemuxer.IsRecording || AudioDemuxer.IsRecording;
+            get => VideoDecoder.isRecording || AudioDecoder.isRecording;
         }
         int oldMaxAudioFrames;
+        bool recHasVideo;
         public void StartRecording(ref string filename, bool useRecommendedExtension = true)
         {
-            oldMaxAudioFrames = -1;
-
-            if (AudioStream == null || AudioStream.Demuxer.Type == MediaType.Video)
-            {
-                VideoDemuxer.StartRecording(ref filename, useRecommendedExtension);
-                return;
-            }
 
             if (IsRecording) StopRecording();
 
+            oldMaxAudioFrames = -1;
+            recHasVideo = false;
+
             Log("Record Start");
-            VideoDemuxer.RecordingCompleted += RecordingCompleted;
+
+            recHasVideo = !VideoDecoder.Disposed && VideoDecoder.Stream != null;
 
             if (useRecommendedExtension)
-                filename = $"{filename}.{VideoDemuxer.Extension}";
+                filename = $"{filename}.{(recHasVideo ? VideoDecoder.Stream.Demuxer.Extension : AudioDecoder.Stream.Demuxer.Extension)}";
 
             Recorder.Open(filename);
-            for(int i=0; i<VideoDemuxer.EnabledStreams.Count; i++)
-                Log(Recorder.AddStream(VideoDemuxer.AVStreamToStream[VideoDemuxer.EnabledStreams[i]].AVStream).ToString());
-
-            for(int i=0; i<AudioDemuxer.EnabledStreams.Count; i++)
-                Log(Recorder.AddStream(AudioDemuxer.AVStreamToStream[AudioDemuxer.EnabledStreams[i]].AVStream, true).ToString());
+            if (recHasVideo)
+                Log(Recorder.AddStream(VideoDecoder.Stream.AVStream).ToString());
+                
+            if (!AudioDecoder.Disposed && AudioDecoder.Stream != null)
+                Log(Recorder.AddStream(AudioDecoder.Stream.AVStream, !AudioDecoder.OnVideoDemuxer).ToString());
 
             if (!Recorder.HasStreams || Recorder.WriteHeader() != 0) return; //throw new Exception("Invalid remuxer configuration");
 
             // Check also buffering and possible Diff of first audio/video timestamp to remuxer to ensure sync between each other (shouldn't be more than 30-50ms)
             oldMaxAudioFrames = Config.Decoder.MaxAudioFrames;
-            long timestamp = Math.Max(VideoDemuxer.CurTime + VideoDemuxer.BufferedDuration, AudioDemuxer.CurTime + AudioDemuxer.BufferedDuration) + 1500 * 10000;
+            //long timestamp = Math.Max(VideoDemuxer.CurTime + VideoDemuxer.BufferedDuration, AudioDemuxer.CurTime + AudioDemuxer.BufferedDuration) + 1500 * 10000;
             Config.Decoder.MaxAudioFrames = Config.Decoder.MaxVideoFrames;
 
-            VideoDemuxer.StartRecording(Recorder, timestamp);
-            AudioDemuxer.StartRecording(Recorder, timestamp);
+            VideoDecoder.StartRecording(Recorder);
+            AudioDecoder.StartRecording(Recorder);
         }
         public void StopRecording()
         {
             if (oldMaxAudioFrames != -1) Config.Decoder.MaxAudioFrames = oldMaxAudioFrames;
 
-            VideoDemuxer.RecordingCompleted -= RecordingCompleted;
-            VideoDemuxer.StopRecording();
-            AudioDemuxer.StopRecording();
+            VideoDecoder.StopRecording();
+            AudioDecoder.StopRecording();
             Recorder.Dispose();
             oldMaxAudioFrames = -1;
             Log("Record Completed");
         }
-        private void RecordingCompleted(object sender, EventArgs e) { StopRecording(); }
+
+        internal void RecordCompleted(MediaType type)
+        {
+            if (!recHasVideo || (recHasVideo && type == MediaType.Video))
+            {
+                StopRecording();
+                RecordingCompleted?.Invoke(this, new EventArgs());
+            }
+        }
         #endregion
 
         private void Log(string msg) { Debug.WriteLine($"[{DateTime.Now.ToString("hh.mm.ss.fff")}] [#{UniqueId}] [DecoderContext] {msg}"); }

FlyleafLib/MediaFramework/MediaContext/DecoderContext.cs

@@ -11,6 +11,7 @@
 
 using FlyleafLib.MediaFramework.MediaStream;
 using FlyleafLib.MediaFramework.MediaFrame;
+using FlyleafLib.MediaFramework.MediaRemuxer;
 
 namespace FlyleafLib.MediaFramework.MediaDecoder
 {
@@ -168,6 +169,15 @@ protected override void RunInternal()
                     demuxer.AudioPackets.TryDequeue(out IntPtr pktPtr);
                     packet = (AVPacket*) pktPtr;
 
+                    if (isRecording)
+                    {
+                        if (!recGotKeyframe && VideoDecoder.StartRecordTime != AV_NOPTS_VALUE && (long)(packet->pts * AudioStream.Timebase) - demuxer.StartTime > VideoDecoder.StartRecordTime)
+                            recGotKeyframe = true;
+
+                        if (recGotKeyframe)
+                            curRecorder.Write(av_packet_clone(packet), !OnVideoDemuxer);
+                    }
+
                     ret = avcodec_send_packet(codecCtx, packet);
                     av_packet_free(&packet);
 
@@ -205,6 +215,8 @@ protected override void RunInternal()
                 }
 
             } while (Status == Status.Running);
+
+            if (isRecording) { StopRecording(); recCompleted(MediaType.Audio); }
         }
 
         [HandleProcessCorruptedStateExceptions]
@@ -291,5 +303,24 @@ public void DisposeFrames()
             }
             Frames = new ConcurrentQueue<AudioFrame>();
         }
+
+        internal Action<MediaType> recCompleted;
+        Remuxer curRecorder;
+        bool recGotKeyframe;
+        internal bool isRecording;
+
+        internal void StartRecording(Remuxer remuxer, long startAt = -1)
+        {
+            if (Disposed || isRecording) return;
+
+            curRecorder     = remuxer;
+            isRecording     = true;
+            recGotKeyframe  = VideoDecoder.Disposed || VideoDecoder.Stream == null;
+        }
+
+        internal void StopRecording()
+        {
+            isRecording = false;
+        }
     }
 }