update live stream buffer

Emby.Server.Implementations/LiveTv/TunerHosts/HdHomerun/HdHomerunHost.cs

@@ -423,7 +423,7 @@ namespace Emby.Server.Implementations.LiveTv.TunerHosts.HdHomerun
                 IsInfiniteStream = true,
                 IgnoreDts = true,
                 //IgnoreIndex = true,
-                ReadAtNativeFramerate = true
+                //ReadAtNativeFramerate = true
             };
 
             mediaSource.InferTotalBitrate();
@@ -513,7 +513,7 @@ namespace Emby.Server.Implementations.LiveTv.TunerHosts.HdHomerun
             // The UDP method is not working reliably on OSX, and on BSD it hasn't been tested yet
             var enableHttpStream = _environment.OperatingSystem == MediaBrowser.Model.System.OperatingSystem.OSX 
                 || _environment.OperatingSystem == MediaBrowser.Model.System.OperatingSystem.BSD;
-            enableHttpStream = true;
+            //enableHttpStream = true;
             if (enableHttpStream)
             {
                 mediaSource.Protocol = MediaProtocol.Http;

Emby.Server.Implementations/LiveTv/TunerHosts/HdHomerun/HdHomerunHttpStream.cs

@@ -12,6 +12,8 @@ using MediaBrowser.Model.Dto;
 using MediaBrowser.Model.Logging;
 using MediaBrowser.Model.MediaInfo;
 using MediaBrowser.Model.System;
+using System.Globalization;
+using MediaBrowser.Controller.IO;
 
 namespace Emby.Server.Implementations.LiveTv.TunerHosts.HdHomerun
 {
@@ -102,12 +104,14 @@ namespace Emby.Server.Implementations.LiveTv.TunerHosts.HdHomerun
                                 _logger.Info("Beginning multicastStream.CopyUntilCancelled");
 
                                 FileSystem.CreateDirectory(FileSystem.GetDirectoryName(_tempFilePath));
-                                using (var fileStream = FileSystem.GetFileStream(_tempFilePath, FileOpenMode.Create, FileAccessMode.Write, FileShareMode.Read, FileOpenOptions.Asynchronous))
+                                using (var fileStream = FileSystem.GetFileStream(_tempFilePath, FileOpenMode.Create, FileAccessMode.Write, FileShareMode.Read, FileOpenOptions.None))
                                 {
                                     ResolveAfterDelay(3000, openTaskCompletionSource);
 
                                     //await response.Content.CopyToAsync(fileStream, 81920, cancellationToken).ConfigureAwait(false);
-                                    await AsyncStreamCopier.CopyStream(response.Content, fileStream, 81920, 4, cancellationToken).ConfigureAwait(false);
+                                    StreamHelper.CopyTo(response.Content, fileStream, 81920, cancellationToken);
+
+                                    //await AsyncStreamCopier.CopyStream(response.Content, fileStream, 81920, 4, cancellationToken).ConfigureAwait(false);
                                 }
                             }
                         }
@@ -147,43 +151,51 @@ namespace Emby.Server.Implementations.LiveTv.TunerHosts.HdHomerun
 
         public Task CopyToAsync(Stream stream, CancellationToken cancellationToken)
         {
-            return CopyFileTo(_tempFilePath, false, stream, cancellationToken);
+            return CopyFileTo(_tempFilePath, stream, cancellationToken);
         }
 
-        protected async Task CopyFileTo(string path, bool allowEndOfFile, Stream outputStream, CancellationToken cancellationToken)
+        protected async Task CopyFileTo(string path, Stream outputStream, CancellationToken cancellationToken)
         {
-            var eofCount = 0;
+            long startPosition = -20000;
-
-            long startPosition = -25000;
             if (startPosition < 0)
             {
                 var length = FileSystem.GetFileInfo(path).Length;
                 startPosition = Math.Max(length - startPosition, 0);
             }
 
-            using (var inputStream = GetInputStream(path, startPosition, true))
+            _logger.Info("Live stream starting position is {0} bytes", startPosition.ToString(CultureInfo.InvariantCulture));
+
+            var allowAsync = Environment.OperatingSystem != MediaBrowser.Model.System.OperatingSystem.Windows;
+            // use non-async filestream along with read due to https://github.com/dotnet/corefx/issues/6039
+
+            using (var inputStream = GetInputStream(path, startPosition, allowAsync))
             {
                 if (startPosition > 0)
                 {
                     inputStream.Position = startPosition;
                 }
 
-                while (eofCount < 20 || !allowEndOfFile)
+                while (!cancellationToken.IsCancellationRequested)
                 {
-                    var bytesRead = await AsyncStreamCopier.CopyStream(inputStream, outputStream, 81920, 4, cancellationToken).ConfigureAwait(false);
+                    long bytesRead;
+
+                    if (allowAsync)
+                    {
+                        bytesRead = await AsyncStreamCopier.CopyStream(inputStream, outputStream, 81920, 2, cancellationToken).ConfigureAwait(false);
+                    }
+                    else
+                    {
+                        StreamHelper.CopyTo(inputStream, outputStream, 81920, cancellationToken);
+                        bytesRead = 1;
+                    }
 
                     //var position = fs.Position;
                     //_logger.Debug("Streamed {0} bytes to position {1} from file {2}", bytesRead, position, path);
 
                     if (bytesRead == 0)
                     {
-                        eofCount++;
                         await Task.Delay(100, cancellationToken).ConfigureAwait(false);
                     }
-                    else
-                    {
-                        eofCount = 0;
-                    }
                 }
             }
         }

Emby.Server.Implementations/LiveTv/TunerHosts/HdHomerun/HdHomerunUdpStream.cs

@@ -16,6 +16,8 @@ using MediaBrowser.Model.Logging;
 using MediaBrowser.Model.MediaInfo;
 using MediaBrowser.Model.Net;
 using MediaBrowser.Model.System;
+using System.Globalization;
+using MediaBrowser.Controller.IO;
 
 namespace Emby.Server.Implementations.LiveTv.TunerHosts.HdHomerun
 {
@@ -122,9 +124,11 @@ namespace Emby.Server.Implementations.LiveTv.TunerHosts.HdHomerun
                                 if (!cancellationToken.IsCancellationRequested)
                                 {
                                     FileSystem.CreateDirectory(FileSystem.GetDirectoryName(_tempFilePath));
-                                    using (var fileStream = FileSystem.GetFileStream(_tempFilePath, FileOpenMode.Create, FileAccessMode.Write, FileShareMode.Read, FileOpenOptions.Asynchronous))
+                                    using (var fileStream = FileSystem.GetFileStream(_tempFilePath, FileOpenMode.Create, FileAccessMode.Write, FileShareMode.Read, FileOpenOptions.None))
                                     {
-                                        await CopyTo(udpClient, fileStream, openTaskCompletionSource, cancellationToken).ConfigureAwait(false);
+                                        ResolveAfterDelay(3000, openTaskCompletionSource);
+
+                                        CopyTo(udpClient, fileStream, openTaskCompletionSource, cancellationToken);
                                     }
                                 }
                             }
@@ -168,78 +172,107 @@ namespace Emby.Server.Implementations.LiveTv.TunerHosts.HdHomerun
 
         public Task CopyToAsync(Stream stream, CancellationToken cancellationToken)
         {
-            return CopyFileTo(_tempFilePath, false, stream, cancellationToken);
+            return CopyFileTo(_tempFilePath, stream, cancellationToken);
         }
 
-        protected async Task CopyFileTo(string path, bool allowEndOfFile, Stream outputStream, CancellationToken cancellationToken)
+        protected async Task CopyFileTo(string path, Stream outputStream, CancellationToken cancellationToken)
         {
-            var eofCount = 0;
+            long startPosition = -20000;
-
-            long startPosition = -25000;
             if (startPosition < 0)
             {
                 var length = FileSystem.GetFileInfo(path).Length;
                 startPosition = Math.Max(length - startPosition, 0);
             }
 
-            using (var inputStream = GetInputStream(path, startPosition, true))
+            _logger.Info("Live stream starting position is {0} bytes", startPosition.ToString(CultureInfo.InvariantCulture));
+
+            var allowAsync = Environment.OperatingSystem != MediaBrowser.Model.System.OperatingSystem.Windows;
+            // use non-async filestream along with read due to https://github.com/dotnet/corefx/issues/6039
+
+            using (var inputStream = GetInputStream(path, startPosition, allowAsync))
             {
                 if (startPosition > 0)
                 {
                     inputStream.Position = startPosition;
                 }
 
-                while (eofCount < 20 || !allowEndOfFile)
+                while (!cancellationToken.IsCancellationRequested)
                 {
-                    var bytesRead = await AsyncStreamCopier.CopyStream(inputStream, outputStream, 81920, 4, cancellationToken).ConfigureAwait(false);
+                    long bytesRead;
+
+                    if (allowAsync)
+                    {
+                        bytesRead = await AsyncStreamCopier.CopyStream(inputStream, outputStream, 81920, 2, cancellationToken).ConfigureAwait(false);
+                    }
+                    else
+                    {
+                        StreamHelper.CopyTo(inputStream, outputStream, 81920, cancellationToken);
+                        bytesRead = 1;
+                    }
 
                     //var position = fs.Position;
                     //_logger.Debug("Streamed {0} bytes to position {1} from file {2}", bytesRead, position, path);
 
                     if (bytesRead == 0)
                     {
-                        eofCount++;
                         await Task.Delay(100, cancellationToken).ConfigureAwait(false);
                     }
-                    else
-                    {
-                        eofCount = 0;
-                    }
                 }
             }
         }
 
-        private static int RtpHeaderBytes = 12;
+        private void ResolveAfterDelay(int delayMs, TaskCompletionSource<bool> openTaskCompletionSource)
-        private Task CopyTo(ISocket udpClient, Stream outputStream, TaskCompletionSource<bool> openTaskCompletionSource, CancellationToken cancellationToken)
         {
-            return CopyStream(_socketFactory.CreateNetworkStream(udpClient, false), outputStream, 81920, 4, openTaskCompletionSource, cancellationToken);
+            Task.Run(async () =>
+            {
+                await Task.Delay(delayMs).ConfigureAwait(false);
+                openTaskCompletionSource.TrySetResult(true);
+            });
         }
 
-        private Task CopyStream(Stream source, Stream target, int bufferSize, int bufferCount, TaskCompletionSource<bool> openTaskCompletionSource, CancellationToken cancellationToken)
+        private static int RtpHeaderBytes = 12;
+        private void CopyTo(ISocket udpClient, Stream target, TaskCompletionSource<bool> openTaskCompletionSource, CancellationToken cancellationToken)
         {
-            var copier = new AsyncStreamCopier(source, target, 0, cancellationToken, false, bufferSize, bufferCount);
+            var source = _socketFactory.CreateNetworkStream(udpClient, false);
-            copier.IndividualReadOffset = RtpHeaderBytes;
+            var bufferSize = 81920;
 
-            var taskCompletion = new TaskCompletionSource<long>();
+            byte[] buffer = new byte[bufferSize];
-
+            int read;
-            copier.TaskCompletionSource = taskCompletion;
+            while ((read = source.Read(buffer, 0, buffer.Length)) != 0)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
 
-            var result = copier.BeginCopy(StreamCopyCallback, copier);
+                read -= RtpHeaderBytes;
 
-            if (openTaskCompletionSource != null)
+                if (read > 0)
-            {
+                {
-                Resolve(openTaskCompletionSource);
+                    target.Write(buffer, RtpHeaderBytes, read);
-                openTaskCompletionSource = null;
+                }
             }
 
-            if (result.CompletedSynchronously)
+            //var copier = new AsyncStreamCopier(source, target, 0, cancellationToken, false, bufferSize, bufferCount);
-            {
+            //copier.IndividualReadOffset = RtpHeaderBytes;
-                StreamCopyCallback(result);
+
-            }
+            //var taskCompletion = new TaskCompletionSource<long>();
+
+            //copier.TaskCompletionSource = taskCompletion;
+
+            //var result = copier.BeginCopy(StreamCopyCallback, copier);
+
+            //if (openTaskCompletionSource != null)
+            //{
+            //    Resolve(openTaskCompletionSource);
+            //    openTaskCompletionSource = null;
+            //}
+
+            //if (result.CompletedSynchronously)
+            //{
+            //    StreamCopyCallback(result);
+            //}
 
-            cancellationToken.Register(() => taskCompletion.TrySetCanceled());
+            //cancellationToken.Register(() => taskCompletion.TrySetCanceled());
 
-            return taskCompletion.Task;
+            //return taskCompletion.Task;
         }
 
         private void StreamCopyCallback(IAsyncResult result)

MediaBrowser.Controller/IO/StreamHelper.cs

@@ -0,0 +1,20 @@
+using System.IO;
+using System.Threading;
+
+namespace MediaBrowser.Controller.IO
+{
+    public static class StreamHelper
+    {
+        public static void CopyTo(Stream source, Stream destination, int bufferSize, CancellationToken cancellationToken)
+        {
+            byte[] buffer = new byte[bufferSize];
+            int read;
+            while ((read = source.Read(buffer, 0, buffer.Length)) != 0)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                destination.Write(buffer, 0, read);
+            }
+        }
+    }
+}

MediaBrowser.Controller/LiveTv/LiveStream.cs

@@ -53,9 +53,7 @@ namespace MediaBrowser.Controller.LiveTv
 
         protected Stream GetInputStream(string path, long startPosition, bool allowAsyncFileRead)
         {
-            var fileOpenOptions = startPosition > 0
+            var fileOpenOptions = FileOpenOptions.SequentialScan;
-                ? FileOpenOptions.RandomAccess
-                : FileOpenOptions.SequentialScan;
 
             if (allowAsyncFileRead)
             {

MediaBrowser.Controller/MediaBrowser.Controller.csproj

@@ -134,6 +134,7 @@
     <Compile Include="Entities\UserViewBuilder.cs" />
     <Compile Include="Extensions\StringExtensions.cs" />
     <Compile Include="FileOrganization\IFileOrganizationService.cs" />
+    <Compile Include="IO\StreamHelper.cs" />
     <Compile Include="Library\DeleteOptions.cs" />
     <Compile Include="Library\ILibraryPostScanTask.cs" />
     <Compile Include="Library\IMediaSourceManager.cs" />