jellyfin-server/MediaBrowser.Api/Playback/Hls/BaseHlsService.cs

300 lines
12 KiB
C#
Raw Normal View History

2013-06-18 10:36:25 +00:00
using MediaBrowser.Common.Extensions;
using MediaBrowser.Common.IO;
using MediaBrowser.Common.MediaInfo;
2013-02-21 01:33:05 +00:00
using MediaBrowser.Common.Net;
using MediaBrowser.Controller;
2013-09-04 17:02:19 +00:00
using MediaBrowser.Controller.Dto;
2013-08-28 22:05:00 +00:00
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Library;
2013-09-28 18:07:01 +00:00
using MediaBrowser.Model.Dto;
2013-08-28 22:05:00 +00:00
using MediaBrowser.Model.IO;
2013-02-21 01:33:05 +00:00
using System;
using System.Collections.Generic;
2013-02-21 01:33:05 +00:00
using System.IO;
2013-08-28 22:05:00 +00:00
using System.Text;
2013-02-21 01:33:05 +00:00
using System.Threading.Tasks;
namespace MediaBrowser.Api.Playback.Hls
2013-02-21 01:33:05 +00:00
{
2013-04-29 16:01:23 +00:00
/// <summary>
/// Class BaseHlsService
/// </summary>
public abstract class BaseHlsService : BaseStreamingService
2013-02-21 01:33:05 +00:00
{
2013-06-18 10:36:25 +00:00
protected override string GetOutputFilePath(StreamState state)
{
var folder = ApplicationPaths.EncodedMediaCachePath;
var outputFileExtension = GetOutputFileExtension(state);
2013-08-28 22:05:00 +00:00
return Path.Combine(folder, GetCommandLineArguments("dummy\\dummy", state, false).GetMD5() + (outputFileExtension ?? string.Empty).ToLower());
2013-06-18 10:36:25 +00:00
}
2013-04-29 16:01:23 +00:00
/// <summary>
/// Initializes a new instance of the <see cref="BaseStreamingService" /> class.
/// </summary>
/// <param name="appPaths">The app paths.</param>
/// <param name="userManager">The user manager.</param>
/// <param name="libraryManager">The library manager.</param>
/// <param name="isoManager">The iso manager.</param>
/// <param name="mediaEncoder">The media encoder.</param>
2013-09-04 17:02:19 +00:00
protected BaseHlsService(IServerApplicationPaths appPaths, IUserManager userManager, ILibraryManager libraryManager, IIsoManager isoManager, IMediaEncoder mediaEncoder, IDtoService dtoService)
: base(appPaths, userManager, libraryManager, isoManager, mediaEncoder, dtoService)
{
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets the audio arguments.
/// </summary>
2013-04-29 16:01:23 +00:00
/// <param name="state">The state.</param>
2013-02-21 01:33:05 +00:00
/// <returns>System.String.</returns>
protected abstract string GetAudioArguments(StreamState state);
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets the video arguments.
/// </summary>
2013-04-29 16:01:23 +00:00
/// <param name="state">The state.</param>
/// <param name="performSubtitleConversion">if set to <c>true</c> [perform subtitle conversion].</param>
2013-02-21 01:33:05 +00:00
/// <returns>System.String.</returns>
2013-04-29 16:01:23 +00:00
protected abstract string GetVideoArguments(StreamState state, bool performSubtitleConversion);
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets the segment file extension.
/// </summary>
/// <param name="state">The state.</param>
/// <returns>System.String.</returns>
protected abstract string GetSegmentFileExtension(StreamState state);
2013-04-29 16:01:23 +00:00
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets the type of the transcoding job.
/// </summary>
/// <value>The type of the transcoding job.</value>
protected override TranscodingJobType TranscodingJobType
{
get { return TranscodingJobType.Hls; }
}
/// <summary>
/// Processes the request.
2013-02-21 01:33:05 +00:00
/// </summary>
2013-04-29 16:01:23 +00:00
/// <param name="request">The request.</param>
/// <returns>System.Object.</returns>
protected object ProcessRequest(StreamRequest request)
2013-02-21 01:33:05 +00:00
{
var state = GetState(request);
2013-06-18 10:36:25 +00:00
return ProcessRequestAsync(state).Result;
2013-02-21 01:33:05 +00:00
}
/// <summary>
/// Processes the request async.
2013-02-21 01:33:05 +00:00
/// </summary>
/// <param name="state">The state.</param>
/// <returns>Task{System.Object}.</returns>
public async Task<object> ProcessRequestAsync(StreamState state)
2013-02-21 01:33:05 +00:00
{
2013-09-28 18:07:01 +00:00
if (!state.VideoRequest.VideoBitRate.HasValue && (!state.VideoRequest.VideoCodec.HasValue || state.VideoRequest.VideoCodec.Value != VideoCodecs.Copy))
2013-08-30 01:25:37 +00:00
{
throw new ArgumentException("A video bitrate is required");
}
2013-09-28 18:07:01 +00:00
if (!state.Request.AudioBitRate.HasValue && (!state.Request.AudioCodec.HasValue || state.Request.AudioCodec.Value != AudioCodecs.Copy))
2013-08-30 01:25:37 +00:00
{
throw new ArgumentException("An audio bitrate is required");
}
var playlist = GetOutputFilePath(state);
2013-02-21 01:33:05 +00:00
var isPlaylistNewlyCreated = false;
// If the playlist doesn't already exist, startup ffmpeg
if (!File.Exists(playlist))
{
isPlaylistNewlyCreated = true;
2013-04-10 15:32:09 +00:00
await StartFfMpeg(state, playlist).ConfigureAwait(false);
2013-02-21 01:33:05 +00:00
}
else
{
2013-03-08 19:14:09 +00:00
ApiEntryPoint.Instance.OnTranscodeBeginRequest(playlist, TranscodingJobType.Hls);
2013-02-21 01:33:05 +00:00
}
2013-08-28 22:05:00 +00:00
if (isPlaylistNewlyCreated)
{
await WaitForMinimumSegmentCount(playlist, 3).ConfigureAwait(false);
}
2013-10-07 18:22:21 +00:00
int audioBitrate;
int videoBitrate;
GetPlaylistBitrates(state, out audioBitrate, out videoBitrate);
2013-08-30 02:13:58 +00:00
2013-09-06 17:27:06 +00:00
var appendBaselineStream = false;
var baselineStreamBitrate = 64000;
var hlsVideoRequest = state.VideoRequest as GetHlsVideoStream;
if (hlsVideoRequest != null)
{
appendBaselineStream = hlsVideoRequest.AppendBaselineStream;
baselineStreamBitrate = hlsVideoRequest.BaselineStreamAudioBitRate ?? baselineStreamBitrate;
}
var playlistText = GetMasterPlaylistFileText(playlist, videoBitrate + audioBitrate, appendBaselineStream, baselineStreamBitrate);
2013-02-21 01:33:05 +00:00
try
{
return ResultFactory.GetResult(playlistText, MimeTypes.GetMimeType("playlist.m3u8"), new Dictionary<string, string>());
2013-02-21 01:33:05 +00:00
}
finally
{
2013-03-08 19:14:09 +00:00
ApiEntryPoint.Instance.OnTranscodeEndRequest(playlist, TranscodingJobType.Hls);
2013-02-21 01:33:05 +00:00
}
}
2013-10-07 18:22:21 +00:00
/// <summary>
/// Gets the playlist bitrates.
/// </summary>
/// <param name="state">The state.</param>
/// <param name="audioBitrate">The audio bitrate.</param>
/// <param name="videoBitrate">The video bitrate.</param>
private void GetPlaylistBitrates(StreamState state, out int audioBitrate, out int videoBitrate)
{
var audioBitrateParam = GetAudioBitrateParam(state);
var videoBitrateParam = GetVideoBitrateParam(state);
if (!audioBitrateParam.HasValue)
{
if (state.AudioStream != null)
{
audioBitrateParam = state.AudioStream.BitRate;
}
}
if (!videoBitrateParam.HasValue)
{
if (state.VideoStream != null)
{
videoBitrateParam = state.VideoStream.BitRate;
}
}
audioBitrate = audioBitrateParam ?? 0;
videoBitrate = videoBitrateParam ?? 0;
}
2013-02-21 01:33:05 +00:00
2013-09-06 17:27:06 +00:00
private string GetMasterPlaylistFileText(string firstPlaylist, int bitrate, bool includeBaselineStream, int baselineStreamBitrate)
2013-02-21 01:33:05 +00:00
{
2013-08-28 22:05:00 +00:00
var builder = new StringBuilder();
builder.AppendLine("#EXTM3U");
2013-09-03 14:37:15 +00:00
// Pad a little to satisfy the apple hls validator
var paddedBitrate = Convert.ToInt32(bitrate * 1.05);
2013-08-28 22:05:00 +00:00
// Main stream
2013-09-03 14:37:15 +00:00
builder.AppendLine("#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=" + paddedBitrate.ToString(UsCulture));
2013-08-28 22:05:00 +00:00
var playlistUrl = "hls/" + Path.GetFileName(firstPlaylist).Replace(".m3u8", "/stream.m3u8");
builder.AppendLine(playlistUrl);
2013-02-21 01:33:05 +00:00
2013-08-28 22:05:00 +00:00
// Low bitrate stream
2013-09-06 17:27:06 +00:00
if (includeBaselineStream)
{
builder.AppendLine("#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=" + baselineStreamBitrate.ToString(UsCulture));
playlistUrl = "hls/" + Path.GetFileName(firstPlaylist).Replace(".m3u8", "-low/stream.m3u8");
builder.AppendLine(playlistUrl);
}
2013-08-28 22:05:00 +00:00
return builder.ToString();
}
private async Task WaitForMinimumSegmentCount(string playlist, int segmentCount)
{
2013-02-21 01:33:05 +00:00
while (true)
{
2013-08-28 22:05:00 +00:00
string fileText;
2013-02-21 01:33:05 +00:00
// Need to use FileShare.ReadWrite because we're reading the file at the same time it's being written
using (var fileStream = new FileStream(playlist, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, StreamDefaults.DefaultFileStreamBufferSize, FileOptions.Asynchronous))
{
using (var reader = new StreamReader(fileStream))
{
fileText = await reader.ReadToEndAsync().ConfigureAwait(false);
}
}
2013-08-28 22:05:00 +00:00
if (CountStringOccurrences(fileText, "#EXTINF:") >= segmentCount)
2013-02-21 01:33:05 +00:00
{
break;
}
await Task.Delay(25).ConfigureAwait(false);
}
}
/// <summary>
/// Count occurrences of strings.
/// </summary>
/// <param name="text">The text.</param>
/// <param name="pattern">The pattern.</param>
/// <returns>System.Int32.</returns>
private static int CountStringOccurrences(string text, string pattern)
{
// Loop through all instances of the string 'text'.
var count = 0;
var i = 0;
while ((i = text.IndexOf(pattern, i, StringComparison.OrdinalIgnoreCase)) != -1)
{
i += pattern.Length;
count++;
}
return count;
}
2013-04-29 16:01:23 +00:00
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets the command line arguments.
2013-02-21 01:33:05 +00:00
/// </summary>
/// <param name="outputPath">The output path.</param>
/// <param name="state">The state.</param>
2013-04-29 16:01:23 +00:00
/// <param name="performSubtitleConversions">if set to <c>true</c> [perform subtitle conversions].</param>
2013-02-21 01:33:05 +00:00
/// <returns>System.String.</returns>
2013-04-29 16:01:23 +00:00
protected override string GetCommandLineArguments(string outputPath, StreamState state, bool performSubtitleConversions)
2013-02-21 01:33:05 +00:00
{
var probeSize = GetProbeSizeArgument(state.Item);
2013-03-25 14:03:37 +00:00
var hlsVideoRequest = state.VideoRequest as GetHlsVideoStream;
var itsOffsetMs = hlsVideoRequest == null
? 0
: ((GetHlsVideoStream) state.VideoRequest).TimeStampOffsetMs;
var itsOffset = itsOffsetMs == 0 ? string.Empty : string.Format("-itsoffset {0} ", TimeSpan.FromMilliseconds(itsOffsetMs).TotalSeconds);
var args = string.Format("{0}{1} {2} {3} -i {4}{5} -threads 0 {6} {7} -sc_threshold 0 {8} -hls_time 10 -start_number 0 -hls_list_size 1440 \"{9}\"",
itsOffset,
2013-02-21 01:33:05 +00:00
probeSize,
2013-05-01 20:07:20 +00:00
GetUserAgentParam(state.Item),
GetFastSeekCommandLineParameter(state.Request),
GetInputArgument(state.Item, state.IsoMount),
GetSlowSeekCommandLineParameter(state.Request),
GetMapArgs(state),
2013-04-29 16:01:23 +00:00
GetVideoArguments(state, performSubtitleConversions),
GetAudioArguments(state),
2013-08-28 22:05:00 +00:00
outputPath
2013-02-21 01:33:05 +00:00
).Trim();
2013-08-28 22:05:00 +00:00
2013-09-06 17:27:06 +00:00
if (hlsVideoRequest != null)
2013-08-28 22:05:00 +00:00
{
2013-09-06 17:27:06 +00:00
if (hlsVideoRequest.AppendBaselineStream && state.Item is Video)
{
var lowBitratePath = Path.Combine(Path.GetDirectoryName(outputPath), Path.GetFileNameWithoutExtension(outputPath) + "-low.m3u8");
2013-08-28 22:05:00 +00:00
2013-09-06 17:27:06 +00:00
var bitrate = hlsVideoRequest.BaselineStreamAudioBitRate ?? 64000;
2013-08-28 22:05:00 +00:00
2013-09-06 17:27:06 +00:00
var lowBitrateParams = string.Format(" -threads 0 -vn -codec:a:0 libmp3lame -ac 2 -ab {1} -hls_time 10 -start_number 0 -hls_list_size 1440 \"{0}\"",
lowBitratePath,
bitrate / 2);
args += " " + lowBitrateParams;
}
2013-08-28 22:05:00 +00:00
}
return args;
2013-02-21 01:33:05 +00:00
}
}
}