Cutlery/jellyfin
1
0
Fork 0
mirror of https://github.com/jellyfin/jellyfin.git synced 2025-07-07 18:24:19 -04:00
Code Issues Packages Projects Releases Wiki Activity

update live stream buffer

Browse Source
This commit is contained in:
Luke Pulverenti 2017-06-01 00:51:43 -04:00
parent 5b12e9fa33
commit 2ca2a21737
6 changed files with 120 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Emby.Server.Implementations/LiveTv/TunerHosts/HdHomerun/HdHomerunHost.cs
View File

@ -423,7 +423,7 @@ namespace Emby.Server.Implementations.LiveTv.TunerHosts.HdHomerun
IsInfiniteStream = true, IsInfiniteStream = true,
IgnoreDts = true, IgnoreDts = true,
//IgnoreIndex = true, //IgnoreIndex = true,
ReadAtNativeFramerate = true //ReadAtNativeFramerate = true
}; };
mediaSource.InferTotalBitrate(); 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 // 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 var enableHttpStream = _environment.OperatingSystem == MediaBrowser.Model.System.OperatingSystem.OSX
|| _environment.OperatingSystem == MediaBrowser.Model.System.OperatingSystem.BSD; || _environment.OperatingSystem == MediaBrowser.Model.System.OperatingSystem.BSD;
enableHttpStream = true; //enableHttpStream = true;
if (enableHttpStream) if (enableHttpStream)
{ {
mediaSource.Protocol = MediaProtocol.Http; mediaSource.Protocol = MediaProtocol.Http;

42
Emby.Server.Implementations/LiveTv/TunerHosts/HdHomerun/HdHomerunHttpStream.cs
View File

@ -12,6 +12,8 @@ using MediaBrowser.Model.Dto;
using MediaBrowser.Model.Logging; using MediaBrowser.Model.Logging;
using MediaBrowser.Model.MediaInfo; using MediaBrowser.Model.MediaInfo;
using MediaBrowser.Model.System; using MediaBrowser.Model.System;
using System.Globalization;
using MediaBrowser.Controller.IO;
namespace Emby.Server.Implementations.LiveTv.TunerHosts.HdHomerun namespace Emby.Server.Implementations.LiveTv.TunerHosts.HdHomerun
{ {
@ -102,12 +104,14 @@ namespace Emby.Server.Implementations.LiveTv.TunerHosts.HdHomerun
_logger.Info("Beginning multicastStream.CopyUntilCancelled"); _logger.Info("Beginning multicastStream.CopyUntilCancelled");
FileSystem.CreateDirectory(FileSystem.GetDirectoryName(_tempFilePath)); 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); ResolveAfterDelay(3000, openTaskCompletionSource);
//await response.Content.CopyToAsync(fileStream, 81920, cancellationToken).ConfigureAwait(false); //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) 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) if (startPosition < 0)
{ {
var length = FileSystem.GetFileInfo(path).Length; var length = FileSystem.GetFileInfo(path).Length;
startPosition = Math.Max(length - startPosition, 0); 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) if (startPosition > 0)
{ {
inputStream.Position = startPosition; 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; //var position = fs.Position;
//_logger.Debug("Streamed {0} bytes to position {1} from file {2}", bytesRead, position, path); //_logger.Debug("Streamed {0} bytes to position {1} from file {2}", bytesRead, position, path);
if (bytesRead == 0) if (bytesRead == 0)
{ {
eofCount++;
await Task.Delay(100, cancellationToken).ConfigureAwait(false); await Task.Delay(100, cancellationToken).ConfigureAwait(false);
} }
else
{
eofCount = 0;
}
} }
} }
} }

105
Emby.Server.Implementations/LiveTv/TunerHosts/HdHomerun/HdHomerunUdpStream.cs
View File

@ -16,6 +16,8 @@ using MediaBrowser.Model.Logging;
using MediaBrowser.Model.MediaInfo; using MediaBrowser.Model.MediaInfo;
using MediaBrowser.Model.Net; using MediaBrowser.Model.Net;
using MediaBrowser.Model.System; using MediaBrowser.Model.System;
using System.Globalization;
using MediaBrowser.Controller.IO;
namespace Emby.Server.Implementations.LiveTv.TunerHosts.HdHomerun namespace Emby.Server.Implementations.LiveTv.TunerHosts.HdHomerun
{ {
@ -122,9 +124,11 @@ namespace Emby.Server.Implementations.LiveTv.TunerHosts.HdHomerun
if (!cancellationToken.IsCancellationRequested) if (!cancellationToken.IsCancellationRequested)
{ {
FileSystem.CreateDirectory(FileSystem.GetDirectoryName(_tempFilePath)); 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) 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) if (startPosition < 0)
{ {
var length = FileSystem.GetFileInfo(path).Length; var length = FileSystem.GetFileInfo(path).Length;
startPosition = Math.Max(length - startPosition, 0); 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) if (startPosition > 0)
{ {
inputStream.Position = startPosition; 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; //var position = fs.Position;
//_logger.Debug("Streamed {0} bytes to position {1} from file {2}", bytesRead, position, path); //_logger.Debug("Streamed {0} bytes to position {1} from file {2}", bytesRead, position, path);
if (bytesRead == 0) if (bytesRead == 0)
{ {
eofCount++;
await Task.Delay(100, cancellationToken).ConfigureAwait(false); await Task.Delay(100, cancellationToken).ConfigureAwait(false);
} }
else }
}
}
private void ResolveAfterDelay(int delayMs, TaskCompletionSource<bool> openTaskCompletionSource)
{ {
eofCount = 0; Task.Run(async () =>
} {
} await Task.Delay(delayMs).ConfigureAwait(false);
} openTaskCompletionSource.TrySetResult(true);
});
} }
private static int RtpHeaderBytes = 12; private static int RtpHeaderBytes = 12;
private Task CopyTo(ISocket udpClient, Stream outputStream, TaskCompletionSource<bool> openTaskCompletionSource, CancellationToken cancellationToken) private void CopyTo(ISocket udpClient, Stream target, TaskCompletionSource<bool> openTaskCompletionSource, CancellationToken cancellationToken)
{ {
return CopyStream(_socketFactory.CreateNetworkStream(udpClient, false), outputStream, 81920, 4, openTaskCompletionSource, cancellationToken); var source = _socketFactory.CreateNetworkStream(udpClient, false);
var bufferSize = 81920;
byte[] buffer = new byte[bufferSize];
int read;
while ((read = source.Read(buffer, 0, buffer.Length)) != 0)
{
cancellationToken.ThrowIfCancellationRequested();
read -= RtpHeaderBytes;
if (read > 0)
{
target.Write(buffer, RtpHeaderBytes, read);
}
} }
private Task CopyStream(Stream source, Stream target, int bufferSize, int bufferCount, TaskCompletionSource<bool> openTaskCompletionSource, CancellationToken cancellationToken) //var copier = new AsyncStreamCopier(source, target, 0, cancellationToken, false, bufferSize, bufferCount);
{ //copier.IndividualReadOffset = RtpHeaderBytes;
var copier = new AsyncStreamCopier(source, target, 0, cancellationToken, false, bufferSize, bufferCount);
copier.IndividualReadOffset = RtpHeaderBytes;
var taskCompletion = new TaskCompletionSource<long>(); //var taskCompletion = new TaskCompletionSource<long>();
copier.TaskCompletionSource = taskCompletion; //copier.TaskCompletionSource = taskCompletion;
var result = copier.BeginCopy(StreamCopyCallback, copier); //var result = copier.BeginCopy(StreamCopyCallback, copier);
if (openTaskCompletionSource != null) //if (openTaskCompletionSource != null)
{ //{
Resolve(openTaskCompletionSource); // Resolve(openTaskCompletionSource);
openTaskCompletionSource = null; // openTaskCompletionSource = null;
} //}
if (result.CompletedSynchronously) //if (result.CompletedSynchronously)
{ //{
StreamCopyCallback(result); // StreamCopyCallback(result);
} //}
cancellationToken.Register(() => taskCompletion.TrySetCanceled()); //cancellationToken.Register(() => taskCompletion.TrySetCanceled());
return taskCompletion.Task; //return taskCompletion.Task;
} }
private void StreamCopyCallback(IAsyncResult result) private void StreamCopyCallback(IAsyncResult result)

20
MediaBrowser.Controller/IO/StreamHelper.cs Normal file
View File

@ -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);
}
}
}
}

4
MediaBrowser.Controller/LiveTv/LiveStream.cs
View File

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

1
MediaBrowser.Controller/MediaBrowser.Controller.csproj
View File

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