jellyfin-server/MediaBrowser.Api/Playback/BaseStreamingService.cs

2259 lines
82 KiB
C#
Raw Normal View History

2015-03-07 22:43:53 +00:00
using MediaBrowser.Common.Extensions;
2013-02-27 04:19:05 +00:00
using MediaBrowser.Common.IO;
using MediaBrowser.Controller.Configuration;
2015-03-07 22:43:53 +00:00
using MediaBrowser.Controller.Devices;
2014-03-25 05:25:03 +00:00
using MediaBrowser.Controller.Dlna;
2013-02-27 04:19:05 +00:00
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Library;
2014-02-20 16:37:41 +00:00
using MediaBrowser.Controller.MediaEncoding;
using MediaBrowser.Model.Configuration;
2014-04-01 22:23:07 +00:00
using MediaBrowser.Model.Dlna;
2014-06-02 19:32:41 +00:00
using MediaBrowser.Model.Dto;
2013-02-27 04:19:05 +00:00
using MediaBrowser.Model.Entities;
2015-03-07 22:43:53 +00:00
using MediaBrowser.Model.Extensions;
using MediaBrowser.Model.IO;
using MediaBrowser.Model.MediaInfo;
2015-06-08 21:32:20 +00:00
using MediaBrowser.Model.Serialization;
2013-02-27 04:19:05 +00:00
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
2013-02-27 04:19:05 +00:00
using System.IO;
using System.Linq;
2014-04-06 17:53:23 +00:00
using System.Text;
2013-02-27 04:19:05 +00:00
using System.Threading;
using System.Threading.Tasks;
2015-10-04 04:23:11 +00:00
using CommonIO;
2013-02-27 04:19:05 +00:00
namespace MediaBrowser.Api.Playback
{
/// <summary>
/// Class BaseStreamingService
/// </summary>
2013-03-16 05:52:33 +00:00
public abstract class BaseStreamingService : BaseApiService
2013-02-27 04:19:05 +00:00
{
/// <summary>
/// Gets or sets the application paths.
/// </summary>
/// <value>The application paths.</value>
protected IServerConfigurationManager ServerConfigurationManager { get; private set; }
2013-02-27 04:19:05 +00:00
/// <summary>
/// Gets or sets the user manager.
/// </summary>
/// <value>The user manager.</value>
2013-09-04 17:02:19 +00:00
protected IUserManager UserManager { get; private set; }
/// <summary>
/// Gets or sets the library manager.
/// </summary>
/// <value>The library manager.</value>
2013-09-04 17:02:19 +00:00
protected ILibraryManager LibraryManager { get; private set; }
2013-03-04 05:43:06 +00:00
2013-02-27 04:19:05 +00:00
/// <summary>
2013-03-04 05:43:06 +00:00
/// Gets or sets the iso manager.
2013-02-27 04:19:05 +00:00
/// </summary>
2013-03-04 05:43:06 +00:00
/// <value>The iso manager.</value>
2013-09-04 17:02:19 +00:00
protected IIsoManager IsoManager { get; private set; }
2013-02-27 04:19:05 +00:00
/// <summary>
/// Gets or sets the media encoder.
/// </summary>
/// <value>The media encoder.</value>
2013-09-04 17:02:19 +00:00
protected IMediaEncoder MediaEncoder { get; private set; }
protected IFileSystem FileSystem { get; private set; }
2013-12-06 03:39:44 +00:00
2014-03-25 05:25:03 +00:00
protected IDlnaManager DlnaManager { get; private set; }
2015-01-20 05:19:13 +00:00
protected IDeviceManager DeviceManager { get; private set; }
2014-06-11 19:31:33 +00:00
protected ISubtitleEncoder SubtitleEncoder { get; private set; }
2015-03-07 22:43:53 +00:00
protected IMediaSourceManager MediaSourceManager { get; private set; }
2015-03-17 03:48:05 +00:00
protected IZipClient ZipClient { get; private set; }
2015-05-04 17:44:25 +00:00
protected IJsonSerializer JsonSerializer { get; private set; }
2013-12-06 03:39:44 +00:00
2013-02-27 04:19:05 +00:00
/// <summary>
/// Initializes a new instance of the <see cref="BaseStreamingService" /> class.
/// </summary>
2015-05-04 17:44:25 +00:00
protected BaseStreamingService(IServerConfigurationManager serverConfig, IUserManager userManager, ILibraryManager libraryManager, IIsoManager isoManager, IMediaEncoder mediaEncoder, IFileSystem fileSystem, IDlnaManager dlnaManager, ISubtitleEncoder subtitleEncoder, IDeviceManager deviceManager, IMediaSourceManager mediaSourceManager, IZipClient zipClient, IJsonSerializer jsonSerializer)
2013-02-27 04:19:05 +00:00
{
2015-05-04 17:44:25 +00:00
JsonSerializer = jsonSerializer;
2015-03-17 03:48:05 +00:00
ZipClient = zipClient;
2015-03-07 22:43:53 +00:00
MediaSourceManager = mediaSourceManager;
2015-01-20 05:19:13 +00:00
DeviceManager = deviceManager;
2014-06-11 19:31:33 +00:00
SubtitleEncoder = subtitleEncoder;
2014-03-25 05:25:03 +00:00
DlnaManager = dlnaManager;
FileSystem = fileSystem;
ServerConfigurationManager = serverConfig;
UserManager = userManager;
LibraryManager = libraryManager;
2013-03-04 05:43:06 +00:00
IsoManager = isoManager;
MediaEncoder = mediaEncoder;
2013-02-27 04:19:05 +00:00
}
/// <summary>
/// Gets the command line arguments.
/// </summary>
/// <param name="outputPath">The output path.</param>
/// <param name="state">The state.</param>
2014-06-10 17:36:06 +00:00
/// <param name="isEncoding">if set to <c>true</c> [is encoding].</param>
2013-02-27 04:19:05 +00:00
/// <returns>System.String.</returns>
2015-03-28 20:22:27 +00:00
protected abstract string GetCommandLineArguments(string outputPath, StreamState state, bool isEncoding);
2013-02-27 04:19:05 +00:00
/// <summary>
/// Gets the type of the transcoding job.
/// </summary>
/// <value>The type of the transcoding job.</value>
protected abstract TranscodingJobType TranscodingJobType { get; }
/// <summary>
/// Gets the output file extension.
/// </summary>
/// <param name="state">The state.</param>
/// <returns>System.String.</returns>
protected virtual string GetOutputFileExtension(StreamState state)
{
2013-12-19 21:51:32 +00:00
return Path.GetExtension(state.RequestedUrl);
2013-02-27 04:19:05 +00:00
}
/// <summary>
/// Gets the output file path.
/// </summary>
/// <param name="state">The state.</param>
/// <returns>System.String.</returns>
private string GetOutputFilePath(StreamState state)
2013-02-27 04:19:05 +00:00
{
2015-01-17 04:29:53 +00:00
var folder = ServerConfigurationManager.ApplicationPaths.TranscodingTempPath;
2015-02-06 05:39:07 +00:00
2013-05-21 17:44:24 +00:00
var outputFileExtension = GetOutputFileExtension(state);
2015-03-28 20:22:27 +00:00
var data = GetCommandLineArguments("dummy\\dummy", state, false);
2014-06-28 19:35:30 +00:00
data += "-" + (state.Request.DeviceId ?? string.Empty);
2015-03-29 18:31:28 +00:00
data += "-" + (state.Request.PlaySessionId ?? string.Empty);
2014-06-28 19:35:30 +00:00
2015-03-10 04:22:42 +00:00
var dataHash = data.GetMD5().ToString("N");
if (EnableOutputInSubFolder)
{
return Path.Combine(folder, dataHash, dataHash + (outputFileExtension ?? string.Empty).ToLower());
}
return Path.Combine(folder, dataHash + (outputFileExtension ?? string.Empty).ToLower());
}
protected virtual bool EnableOutputInSubFolder
{
get { return false; }
2013-02-27 04:19:05 +00:00
}
protected readonly CultureInfo UsCulture = new CultureInfo("en-US");
2013-02-27 04:19:05 +00:00
/// <summary>
/// Gets the fast seek command line parameter.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>System.String.</returns>
/// <value>The fast seek command line parameter.</value>
protected string GetFastSeekCommandLineParameter(StreamRequest request)
{
2015-05-19 19:15:40 +00:00
var time = request.StartTimeTicks ?? 0;
2013-02-27 04:19:05 +00:00
2015-05-19 19:15:40 +00:00
if (time > 0)
{
2015-05-21 20:53:14 +00:00
return string.Format("-ss {0}", MediaEncoder.GetTimeParameter(time));
2013-02-27 04:19:05 +00:00
}
return string.Empty;
}
/// <summary>
/// Gets the map args.
/// </summary>
/// <param name="state">The state.</param>
/// <returns>System.String.</returns>
protected virtual string GetMapArgs(StreamState state)
2013-02-27 04:19:05 +00:00
{
2014-05-18 19:58:42 +00:00
// If we don't have known media info
// If input is video, use -sn to drop subtitles
// Otherwise just return empty
if (state.VideoStream == null && state.AudioStream == null)
{
return state.IsInputVideo ? "-sn" : string.Empty;
}
2013-02-27 04:19:05 +00:00
2014-05-18 19:58:42 +00:00
// We have media info, but we don't know the stream indexes
if (state.VideoStream != null && state.VideoStream.Index == -1)
{
return "-sn";
}
// We have media info, but we don't know the stream indexes
if (state.AudioStream != null && state.AudioStream.Index == -1)
2013-05-01 20:07:20 +00:00
{
2014-04-15 03:54:52 +00:00
return state.IsInputVideo ? "-sn" : string.Empty;
2013-05-01 20:07:20 +00:00
}
2014-05-18 19:58:42 +00:00
var args = string.Empty;
2013-02-27 04:19:05 +00:00
if (state.VideoStream != null)
{
args += string.Format("-map 0:{0}", state.VideoStream.Index);
}
else
{
args += "-map -0:v";
}
if (state.AudioStream != null)
{
args += string.Format(" -map 0:{0}", state.AudioStream.Index);
}
2013-05-01 20:07:20 +00:00
2013-02-27 04:19:05 +00:00
else
{
args += " -map -0:a";
}
if (state.SubtitleStream == null)
{
args += " -map -0:s";
}
2014-12-20 06:06:27 +00:00
else if (state.SubtitleStream.IsExternal && !state.SubtitleStream.IsTextSubtitleStream)
{
args += " -map 1:0 -sn";
}
2013-02-27 04:19:05 +00:00
return args;
}
/// <summary>
/// Determines which stream will be used for playback
/// </summary>
/// <param name="allStream">All stream.</param>
/// <param name="desiredIndex">Index of the desired.</param>
/// <param name="type">The type.</param>
/// <param name="returnFirstIfNoIndex">if set to <c>true</c> [return first if no index].</param>
/// <returns>MediaStream.</returns>
private MediaStream GetMediaStream(IEnumerable<MediaStream> allStream, int? desiredIndex, MediaStreamType type, bool returnFirstIfNoIndex = true)
{
var streams = allStream.Where(s => s.Type == type).OrderBy(i => i.Index).ToList();
2013-02-27 04:19:05 +00:00
if (desiredIndex.HasValue)
{
var stream = streams.FirstOrDefault(s => s.Index == desiredIndex.Value);
if (stream != null)
{
return stream;
}
}
2014-04-01 22:23:07 +00:00
if (type == MediaStreamType.Video)
{
streams = streams.Where(i => !string.Equals(i.Codec, "mjpeg", StringComparison.OrdinalIgnoreCase)).ToList();
}
if (returnFirstIfNoIndex && type == MediaStreamType.Audio)
{
return streams.FirstOrDefault(i => i.Channels.HasValue && i.Channels.Value > 0) ??
streams.FirstOrDefault();
}
2013-02-27 04:19:05 +00:00
// Just return the first one
return returnFirstIfNoIndex ? streams.FirstOrDefault() : null;
}
/// <summary>
/// Gets the number of threads.
/// </summary>
/// <returns>System.Int32.</returns>
protected int GetNumberOfThreads(StreamState state, bool isWebm)
{
2015-07-31 01:52:11 +00:00
var threads = ApiEntryPoint.Instance.GetEncodingOptions().EncodingThreadCount;
2014-10-16 03:26:39 +00:00
if (isWebm)
{
// Recommended per docs
return Math.Max(Environment.ProcessorCount - 1, 2);
}
2014-12-20 06:06:27 +00:00
2015-07-31 01:52:11 +00:00
// Automatic
if (threads == -1)
{
return 0;
}
return threads;
}
2015-11-27 04:33:20 +00:00
protected string GetH264Encoder(StreamState state)
2014-12-19 04:20:07 +00:00
{
2015-11-27 04:33:20 +00:00
if (string.Equals(ApiEntryPoint.Instance.GetEncodingOptions().HardwareAccelerationType, "qsv", StringComparison.OrdinalIgnoreCase))
2014-12-19 04:20:07 +00:00
{
2015-11-27 04:33:20 +00:00
// It's currently failing on live tv
if (state.RunTimeTicks.HasValue)
{
return "h264_qsv";
}
2014-12-19 04:20:07 +00:00
}
2015-11-27 04:33:20 +00:00
return "libx264";
2014-12-19 04:20:07 +00:00
}
/// <summary>
/// Gets the video bitrate to specify on the command line
/// </summary>
/// <param name="state">The state.</param>
/// <param name="videoCodec">The video codec.</param>
2014-03-27 19:30:21 +00:00
/// <param name="isHls">if set to <c>true</c> [is HLS].</param>
/// <returns>System.String.</returns>
2014-02-02 14:47:00 +00:00
protected string GetVideoQualityParam(StreamState state, string videoCodec, bool isHls)
{
2014-02-02 14:47:00 +00:00
var param = string.Empty;
2014-04-08 04:17:18 +00:00
var isVc1 = state.VideoStream != null &&
2014-04-02 21:55:19 +00:00
string.Equals(state.VideoStream.Codec, "vc1", StringComparison.OrdinalIgnoreCase);
2015-01-11 03:06:16 +00:00
if (string.Equals(videoCodec, "libx264", StringComparison.OrdinalIgnoreCase))
2014-02-02 14:47:00 +00:00
{
2015-01-11 03:06:16 +00:00
param = "-preset superfast";
2015-11-30 17:23:36 +00:00
param += " -crf 23";
2015-01-11 03:06:16 +00:00
}
else if (string.Equals(videoCodec, "libx265", StringComparison.OrdinalIgnoreCase))
{
param = "-preset fast";
2015-07-31 01:52:11 +00:00
param += " -crf 28";
2014-02-02 14:47:00 +00:00
}
2015-01-14 04:02:57 +00:00
// h264 (h264_qsv)
else if (string.Equals(videoCodec, "h264_qsv", StringComparison.OrdinalIgnoreCase))
{
2015-11-27 04:33:20 +00:00
param = "-preset 7 -look_ahead 0";
2015-01-14 04:02:57 +00:00
}
2015-02-01 20:00:02 +00:00
// h264 (libnvenc)
else if (string.Equals(videoCodec, "libnvenc", StringComparison.OrdinalIgnoreCase))
{
2015-07-31 01:52:11 +00:00
param = "-preset high-performance";
2015-02-01 20:00:02 +00:00
}
// webm
2014-02-02 14:47:00 +00:00
else if (string.Equals(videoCodec, "libvpx", StringComparison.OrdinalIgnoreCase))
{
2014-04-02 21:55:19 +00:00
// Values 0-3, 0 being highest quality but slower
var profileScore = 0;
string crf;
2014-08-30 14:26:29 +00:00
var qmin = "0";
var qmax = "50";
2014-04-02 21:55:19 +00:00
2015-07-31 01:52:11 +00:00
crf = "10";
2014-04-02 21:55:19 +00:00
if (isVc1)
{
2014-04-18 17:16:25 +00:00
profileScore++;
}
2014-04-02 21:55:19 +00:00
2014-08-29 12:14:41 +00:00
// Max of 2
profileScore = Math.Min(profileScore, 2);
2014-08-30 14:26:29 +00:00
2014-04-02 21:55:19 +00:00
// http://www.webmproject.org/docs/encoder-parameters/
2014-08-30 14:26:29 +00:00
param = string.Format("-speed 16 -quality good -profile:v {0} -slices 8 -crf {1} -qmin {2} -qmax {3}",
2014-04-02 21:55:19 +00:00
profileScore.ToString(UsCulture),
2014-08-30 14:26:29 +00:00
crf,
qmin,
qmax);
2014-02-02 14:47:00 +00:00
}
else if (string.Equals(videoCodec, "mpeg4", StringComparison.OrdinalIgnoreCase))
{
param = "-mbd rd -flags +mv4+aic -trellis 2 -cmp 2 -subcmp 2 -bf 2";
}
// asf/wmv
2014-02-02 14:47:00 +00:00
else if (string.Equals(videoCodec, "wmv2", StringComparison.OrdinalIgnoreCase))
2014-01-10 13:52:01 +00:00
{
2014-02-02 14:47:00 +00:00
param = "-qmin 2";
2014-01-10 13:52:01 +00:00
}
2014-02-02 14:47:00 +00:00
else if (string.Equals(videoCodec, "msmpeg4", StringComparison.OrdinalIgnoreCase))
2014-01-10 13:52:01 +00:00
{
2014-02-02 14:47:00 +00:00
param = "-mbd 2";
2014-01-10 13:52:01 +00:00
}
2014-02-02 14:47:00 +00:00
param += GetVideoBitrateParam(state, videoCodec, isHls);
var framerate = GetFramerateParam(state);
if (framerate.HasValue)
{
2014-02-02 14:47:00 +00:00
param += string.Format(" -r {0}", framerate.Value.ToString(UsCulture));
}
if (!string.IsNullOrEmpty(state.OutputVideoSync))
2014-02-02 14:47:00 +00:00
{
param += " -vsync " + state.OutputVideoSync;
2014-02-02 14:47:00 +00:00
}
if (!string.IsNullOrEmpty(state.VideoRequest.Profile))
{
param += " -profile:v " + state.VideoRequest.Profile;
}
if (!string.IsNullOrEmpty(state.VideoRequest.Level))
{
2015-11-27 04:33:20 +00:00
var h264Encoder = GetH264Encoder(state);
2015-02-01 20:00:02 +00:00
// h264_qsv and libnvenc expect levels to be expressed as a decimal. libx264 supports decimal and non-decimal format
2015-11-27 04:33:20 +00:00
if (String.Equals(h264Encoder, "h264_qsv", StringComparison.OrdinalIgnoreCase) || String.Equals(h264Encoder, "libnvenc", StringComparison.OrdinalIgnoreCase))
2015-02-01 20:00:02 +00:00
{
switch (state.VideoRequest.Level)
{
case "30":
param += " -level 3";
break;
case "31":
param += " -level 3.1";
break;
case "32":
param += " -level 3.2";
break;
case "40":
param += " -level 4";
break;
case "41":
param += " -level 4.1";
break;
case "42":
param += " -level 4.2";
break;
case "50":
param += " -level 5";
break;
case "51":
param += " -level 5.1";
break;
case "52":
param += " -level 5.2";
break;
default:
param += " -level " + state.VideoRequest.Level;
break;
}
}
else
{
param += " -level " + state.VideoRequest.Level;
}
2014-02-02 14:47:00 +00:00
}
2015-02-06 05:39:07 +00:00
return "-pix_fmt yuv420p " + param;
2014-01-10 13:52:01 +00:00
}
protected string GetAudioFilterParam(StreamState state, bool isHls)
{
var volParam = string.Empty;
var audioSampleRate = string.Empty;
var channels = state.OutputAudioChannels;
2014-01-20 15:04:50 +00:00
2014-01-10 13:52:01 +00:00
// Boost volume to 200% when downsampling from 6ch to 2ch
2014-04-08 04:17:18 +00:00
if (channels.HasValue && channels.Value <= 2)
{
2014-04-08 04:17:18 +00:00
if (state.AudioStream != null && state.AudioStream.Channels.HasValue && state.AudioStream.Channels.Value > 5)
{
2014-12-21 19:40:37 +00:00
volParam = ",volume=" + ApiEntryPoint.Instance.GetEncodingOptions().DownMixAudioBoost.ToString(UsCulture);
2014-04-08 04:17:18 +00:00
}
}
2014-01-10 13:52:01 +00:00
if (state.OutputAudioSampleRate.HasValue)
{
audioSampleRate = state.OutputAudioSampleRate.Value + ":";
}
2014-01-10 13:52:01 +00:00
var adelay = isHls ? "adelay=1," : string.Empty;
var pts = string.Empty;
2014-06-11 20:57:18 +00:00
if (state.SubtitleStream != null && state.SubtitleStream.IsTextSubtitleStream)
2014-01-10 13:52:01 +00:00
{
2014-05-12 18:04:25 +00:00
var seconds = TimeSpan.FromTicks(state.Request.StartTimeTicks ?? 0).TotalSeconds;
2014-01-10 13:52:01 +00:00
2014-05-12 18:04:25 +00:00
pts = string.Format(",asetpts=PTS-{0}/TB", Math.Round(seconds).ToString(UsCulture));
2014-01-10 13:52:01 +00:00
}
2014-01-20 15:04:50 +00:00
return string.Format("-af \"{0}aresample={1}async={4}{2}{3}\"",
2014-01-10 13:52:01 +00:00
adelay,
2014-01-20 15:04:50 +00:00
audioSampleRate,
2014-01-10 13:52:01 +00:00
volParam,
2014-01-15 05:05:19 +00:00
pts,
state.OutputAudioSync);
}
2013-12-19 21:51:32 +00:00
2013-02-27 04:19:05 +00:00
/// <summary>
/// If we're going to put a fixed size on the command line, this will calculate it
/// </summary>
/// <param name="state">The state.</param>
/// <param name="outputVideoCodec">The output video codec.</param>
/// <param name="allowTimeStampCopy">if set to <c>true</c> [allow time stamp copy].</param>
2013-02-27 04:19:05 +00:00
/// <returns>System.String.</returns>
2014-06-02 19:32:41 +00:00
protected string GetOutputSizeParam(StreamState state,
string outputVideoCodec,
bool allowTimeStampCopy = true)
2013-02-27 04:19:05 +00:00
{
// http://sonnati.wordpress.com/2012/10/19/ffmpeg-the-swiss-army-knife-of-internet-streaming-part-vi/
2013-03-09 02:34:54 +00:00
var request = state.VideoRequest;
2013-02-27 04:19:05 +00:00
2014-06-20 15:10:40 +00:00
var filters = new List<string>();
2014-06-20 15:10:40 +00:00
if (state.DeInterlace)
{
filters.Add("yadif=0:-1:0");
2013-02-27 04:19:05 +00:00
}
// If fixed dimensions were supplied
if (request.Width.HasValue && request.Height.HasValue)
{
2013-12-21 18:37:34 +00:00
var widthParam = request.Width.Value.ToString(UsCulture);
var heightParam = request.Height.Value.ToString(UsCulture);
2014-06-20 15:10:40 +00:00
filters.Add(string.Format("scale=trunc({0}/2)*2:trunc({1}/2)*2", widthParam, heightParam));
2013-02-27 04:19:05 +00:00
}
2014-03-27 23:01:42 +00:00
// If Max dimensions were supplied, for width selects lowest even number between input width and width req size and selects lowest even number from in width*display aspect and requested size
2014-06-20 15:10:40 +00:00
else if (request.MaxWidth.HasValue && request.MaxHeight.HasValue)
{
2014-03-27 23:01:42 +00:00
var maxWidthParam = request.MaxWidth.Value.ToString(UsCulture);
var maxHeightParam = request.MaxHeight.Value.ToString(UsCulture);
2015-05-01 03:00:46 +00:00
filters.Add(string.Format("scale=trunc(min(max(iw\\,ih*dar)\\,min({0}\\,{1}*dar))/2)*2:trunc(min(max(iw/dar\\,ih)\\,min({0}/dar\\,{1}))/2)*2", maxWidthParam, maxHeightParam));
}
2013-02-27 04:19:05 +00:00
// If a fixed width was requested
2014-06-20 15:10:40 +00:00
else if (request.Width.HasValue)
2013-02-27 04:19:05 +00:00
{
2013-12-21 18:37:34 +00:00
var widthParam = request.Width.Value.ToString(UsCulture);
2013-12-22 18:58:51 +00:00
2014-06-20 15:10:40 +00:00
filters.Add(string.Format("scale={0}:trunc(ow/a/2)*2", widthParam));
2013-02-27 04:19:05 +00:00
}
2013-10-06 01:04:41 +00:00
// If a fixed height was requested
2014-06-20 15:10:40 +00:00
else if (request.Height.HasValue)
2013-10-06 01:04:41 +00:00
{
2013-12-21 18:37:34 +00:00
var heightParam = request.Height.Value.ToString(UsCulture);
2013-12-22 18:58:51 +00:00
2014-06-20 15:10:40 +00:00
filters.Add(string.Format("scale=trunc(oh*a*2)/2:{0}", heightParam));
2013-10-06 01:04:41 +00:00
}
2013-02-27 04:19:05 +00:00
// If a max width was requested
2015-05-01 03:00:46 +00:00
else if (request.MaxWidth.HasValue)
2013-02-27 04:19:05 +00:00
{
2013-12-21 18:37:34 +00:00
var maxWidthParam = request.MaxWidth.Value.ToString(UsCulture);
2013-12-22 18:58:51 +00:00
2014-06-20 15:10:40 +00:00
filters.Add(string.Format("scale=min(iw\\,{0}):trunc(ow/dar/2)*2", maxWidthParam));
2013-02-27 04:19:05 +00:00
}
2013-10-06 01:04:41 +00:00
// If a max height was requested
2015-05-01 03:00:46 +00:00
else if (request.MaxHeight.HasValue)
2013-10-06 01:04:41 +00:00
{
2013-12-21 18:37:34 +00:00
var maxHeightParam = request.MaxHeight.Value.ToString(UsCulture);
2013-12-22 18:58:51 +00:00
2015-07-08 16:10:34 +00:00
filters.Add(string.Format("scale=trunc(oh*a/2)*2:min(ih\\,{0})", maxHeightParam));
2013-10-06 01:04:41 +00:00
}
2015-01-14 04:02:57 +00:00
if (string.Equals(outputVideoCodec, "h264_qsv", StringComparison.OrdinalIgnoreCase))
{
2015-11-27 04:33:20 +00:00
if (filters.Count > 1)
{
//filters[filters.Count - 1] += ":flags=fast_bilinear";
}
2015-01-14 04:02:57 +00:00
}
2014-06-20 15:10:40 +00:00
var output = string.Empty;
if (state.SubtitleStream != null && state.SubtitleStream.IsTextSubtitleStream)
{
2014-08-17 05:38:13 +00:00
var subParam = GetTextSubtitleParam(state);
2013-02-27 04:19:05 +00:00
2014-06-20 15:10:40 +00:00
filters.Add(subParam);
2013-02-27 04:19:05 +00:00
if (allowTimeStampCopy)
{
output += " -copyts";
}
2014-06-20 15:10:40 +00:00
}
2013-02-27 04:19:05 +00:00
2014-06-20 15:10:40 +00:00
if (filters.Count > 0)
{
output += string.Format(" -vf \"{0}\"", string.Join(",", filters.ToArray()));
}
2013-02-27 04:19:05 +00:00
2014-06-20 15:10:40 +00:00
return output;
2013-02-27 04:19:05 +00:00
}
/// <summary>
/// Gets the text subtitle param.
/// </summary>
2013-12-19 21:51:32 +00:00
/// <param name="state">The state.</param>
2013-02-27 04:19:05 +00:00
/// <returns>System.String.</returns>
2014-08-17 05:38:13 +00:00
protected string GetTextSubtitleParam(StreamState state)
2013-02-27 04:19:05 +00:00
{
2014-06-26 17:04:11 +00:00
var seconds = Math.Round(TimeSpan.FromTicks(state.Request.StartTimeTicks ?? 0).TotalSeconds);
2014-01-10 13:52:01 +00:00
2014-06-10 17:36:06 +00:00
if (state.SubtitleStream.IsExternal)
2013-02-27 04:19:05 +00:00
{
2014-06-10 17:36:06 +00:00
var subtitlePath = state.SubtitleStream.Path;
2014-06-10 17:36:06 +00:00
var charsetParam = string.Empty;
2013-02-27 04:19:05 +00:00
2014-06-10 17:36:06 +00:00
if (!string.IsNullOrEmpty(state.SubtitleStream.Language))
{
2015-03-31 16:24:16 +00:00
var charenc = SubtitleEncoder.GetSubtitleFileCharacterSet(subtitlePath, state.MediaSource.Protocol, CancellationToken.None).Result;
2013-06-04 02:02:49 +00:00
2014-06-10 17:36:06 +00:00
if (!string.IsNullOrEmpty(charenc))
{
charsetParam = ":charenc=" + charenc;
}
2013-02-27 04:19:05 +00:00
}
2014-07-17 03:17:14 +00:00
// TODO: Perhaps also use original_size=1920x800 ??
2014-06-20 15:10:40 +00:00
return string.Format("subtitles=filename='{0}'{1},setpts=PTS -{2}/TB",
2015-08-16 15:53:30 +00:00
MediaEncoder.EscapeSubtitleFilterPath(subtitlePath),
2014-06-10 17:36:06 +00:00
charsetParam,
2014-06-26 17:04:11 +00:00
seconds.ToString(UsCulture));
2013-02-27 04:19:05 +00:00
}
2015-03-28 20:22:27 +00:00
var mediaPath = state.MediaPath ?? string.Empty;
2014-06-20 15:10:40 +00:00
return string.Format("subtitles='{0}:si={1}',setpts=PTS -{2}/TB",
2015-08-16 15:53:30 +00:00
MediaEncoder.EscapeSubtitleFilterPath(mediaPath),
2014-06-12 02:38:40 +00:00
state.InternalSubtitleStreamOffset.ToString(UsCulture),
2014-06-26 17:04:11 +00:00
seconds.ToString(UsCulture));
2013-02-27 04:19:05 +00:00
}
/// <summary>
/// Gets the internal graphical subtitle param.
/// </summary>
/// <param name="state">The state.</param>
/// <param name="outputVideoCodec">The output video codec.</param>
/// <returns>System.String.</returns>
2014-07-30 03:31:35 +00:00
protected string GetGraphicalSubtitleParam(StreamState state, string outputVideoCodec)
2013-02-27 04:19:05 +00:00
{
var outputSizeParam = string.Empty;
2013-03-09 02:34:54 +00:00
var request = state.VideoRequest;
2013-02-27 04:19:05 +00:00
// Add resolution params, if specified
if (request.Width.HasValue || request.Height.HasValue || request.MaxHeight.HasValue || request.MaxWidth.HasValue)
{
2014-08-17 05:38:13 +00:00
outputSizeParam = GetOutputSizeParam(state, outputVideoCodec).TrimEnd('"');
2013-02-27 04:19:05 +00:00
outputSizeParam = "," + outputSizeParam.Substring(outputSizeParam.IndexOf("scale", StringComparison.OrdinalIgnoreCase));
}
2014-01-06 02:57:30 +00:00
var videoSizeParam = string.Empty;
if (state.VideoStream != null && state.VideoStream.Width.HasValue && state.VideoStream.Height.HasValue)
{
videoSizeParam = string.Format(",scale={0}:{1}", state.VideoStream.Width.Value.ToString(UsCulture), state.VideoStream.Height.Value.ToString(UsCulture));
}
2014-12-20 06:06:27 +00:00
var mapPrefix = state.SubtitleStream.IsExternal ?
1 :
0;
var subtitleStreamIndex = state.SubtitleStream.IsExternal
? 0
: state.SubtitleStream.Index;
return string.Format(" -filter_complex \"[{0}:{1}]format=yuva444p{4},lut=u=128:v=128:y=gammaval(.3)[sub] ; [0:{2}] [sub] overlay{3}\"",
mapPrefix.ToString(UsCulture),
subtitleStreamIndex.ToString(UsCulture),
state.VideoStream.Index.ToString(UsCulture),
2014-01-06 02:57:30 +00:00
outputSizeParam,
videoSizeParam);
2013-02-27 04:19:05 +00:00
}
/// <summary>
/// Gets the probe size argument.
/// </summary>
/// <param name="state">The state.</param>
/// <returns>System.String.</returns>
private string GetProbeSizeArgument(StreamState state)
{
if (state.PlayableStreamFileNames.Count > 0)
{
return MediaEncoder.GetProbeSizeArgument(state.PlayableStreamFileNames.ToArray(), state.InputProtocol);
}
return MediaEncoder.GetProbeSizeArgument(new[] { state.MediaPath }, state.InputProtocol);
}
2013-02-27 04:19:05 +00:00
/// <summary>
/// Gets the number of audio channels to specify on the command line
/// </summary>
/// <param name="request">The request.</param>
/// <param name="audioStream">The audio stream.</param>
/// <param name="outputAudioCodec">The output audio codec.</param>
2013-02-27 04:19:05 +00:00
/// <returns>System.Nullable{System.Int32}.</returns>
private int? GetNumAudioChannelsParam(StreamRequest request, MediaStream audioStream, string outputAudioCodec)
2013-02-27 04:19:05 +00:00
{
var inputChannels = audioStream == null
? null
: audioStream.Channels;
2014-03-31 21:04:22 +00:00
2015-06-15 04:17:12 +00:00
if (inputChannels <= 0)
{
inputChannels = null;
}
var codec = outputAudioCodec ?? string.Empty;
if (codec.IndexOf("wma", StringComparison.OrdinalIgnoreCase) != -1)
{
// wmav2 currently only supports two channel output
return Math.Min(2, inputChannels ?? 2);
2013-02-27 04:19:05 +00:00
}
2014-03-23 05:10:33 +00:00
if (request.MaxAudioChannels.HasValue)
{
if (inputChannels.HasValue)
2014-03-23 05:10:33 +00:00
{
return Math.Min(request.MaxAudioChannels.Value, inputChannels.Value);
2014-03-23 05:10:33 +00:00
}
var channelLimit = codec.IndexOf("mp3", StringComparison.OrdinalIgnoreCase) != -1
? 2
2015-08-30 17:52:44 +00:00
: 6;
2014-12-24 06:28:40 +00:00
// If we don't have any media info then limit it to 5 to prevent encoding errors due to asking for too many channels
return Math.Min(request.MaxAudioChannels.Value, channelLimit);
2014-03-23 05:10:33 +00:00
}
2013-02-27 04:19:05 +00:00
return request.AudioChannels;
}
/// <summary>
/// Determines whether the specified stream is H264.
/// </summary>
/// <param name="stream">The stream.</param>
/// <returns><c>true</c> if the specified stream is H264; otherwise, <c>false</c>.</returns>
protected bool IsH264(MediaStream stream)
{
2014-10-22 04:42:26 +00:00
var codec = stream.Codec ?? string.Empty;
return codec.IndexOf("264", StringComparison.OrdinalIgnoreCase) != -1 ||
codec.IndexOf("avc", StringComparison.OrdinalIgnoreCase) != -1;
2013-02-27 04:19:05 +00:00
}
/// <summary>
2015-06-03 03:15:46 +00:00
/// Gets the audio encoder.
2013-02-27 04:19:05 +00:00
/// </summary>
2015-07-25 17:21:10 +00:00
/// <param name="state">The state.</param>
2013-02-27 04:19:05 +00:00
/// <returns>System.String.</returns>
2015-07-25 17:21:10 +00:00
protected string GetAudioEncoder(StreamState state)
2013-02-27 04:19:05 +00:00
{
2015-07-25 17:21:10 +00:00
var codec = state.OutputAudioCodec;
2013-02-27 04:19:05 +00:00
2014-03-25 05:25:03 +00:00
if (string.Equals(codec, "aac", StringComparison.OrdinalIgnoreCase))
2013-02-27 04:19:05 +00:00
{
2014-03-25 05:25:03 +00:00
return "aac -strict experimental";
}
if (string.Equals(codec, "mp3", StringComparison.OrdinalIgnoreCase))
{
return "libmp3lame";
}
if (string.Equals(codec, "vorbis", StringComparison.OrdinalIgnoreCase))
{
return "libvorbis";
}
if (string.Equals(codec, "wma", StringComparison.OrdinalIgnoreCase))
{
return "wmav2";
2013-02-27 04:19:05 +00:00
}
2014-03-25 05:25:03 +00:00
return codec.ToLower();
2013-02-27 04:19:05 +00:00
}
/// <summary>
/// Gets the name of the output video codec
/// </summary>
2015-07-25 17:21:10 +00:00
/// <param name="state">The state.</param>
2013-02-27 04:19:05 +00:00
/// <returns>System.String.</returns>
2015-07-25 17:21:10 +00:00
protected string GetVideoEncoder(StreamState state)
2013-02-27 04:19:05 +00:00
{
2015-07-25 17:21:10 +00:00
var codec = state.OutputVideoCodec;
2013-02-27 04:19:05 +00:00
2014-03-23 20:07:02 +00:00
if (!string.IsNullOrEmpty(codec))
2013-02-27 04:19:05 +00:00
{
2014-03-23 20:07:02 +00:00
if (string.Equals(codec, "h264", StringComparison.OrdinalIgnoreCase))
2013-02-27 04:19:05 +00:00
{
2015-11-27 04:33:20 +00:00
return GetH264Encoder(state);
2013-02-27 04:19:05 +00:00
}
2014-03-23 20:07:02 +00:00
if (string.Equals(codec, "vpx", StringComparison.OrdinalIgnoreCase))
2013-02-27 04:19:05 +00:00
{
return "libvpx";
}
2014-03-23 20:07:02 +00:00
if (string.Equals(codec, "wmv", StringComparison.OrdinalIgnoreCase))
2013-02-27 04:19:05 +00:00
{
return "wmv2";
2013-02-27 04:19:05 +00:00
}
2014-03-23 20:07:02 +00:00
if (string.Equals(codec, "theora", StringComparison.OrdinalIgnoreCase))
2013-02-27 04:19:05 +00:00
{
return "libtheora";
}
2014-03-23 20:07:02 +00:00
return codec.ToLower();
2013-02-27 04:19:05 +00:00
}
return "copy";
}
/// <summary>
/// Gets the name of the output video codec
/// </summary>
/// <param name="state">The state.</param>
/// <returns>System.String.</returns>
protected string GetVideoDecoder(StreamState state)
{
2015-11-27 04:33:20 +00:00
if (string.Equals(ApiEntryPoint.Instance.GetEncodingOptions().HardwareAccelerationType, "qsv", StringComparison.OrdinalIgnoreCase))
{
if (state.VideoStream != null && !string.IsNullOrWhiteSpace(state.VideoStream.Codec))
{
switch (state.MediaSource.VideoStream.Codec.ToLower())
{
case "avc":
case "h264":
if (MediaEncoder.SupportsDecoder("h264_qsv"))
{
return "-c:v h264_qsv ";
}
break;
case "mpeg2video":
if (MediaEncoder.SupportsDecoder("mpeg2_qsv"))
{
return "-c:v mpeg2_qsv ";
}
break;
case "vc1":
if (MediaEncoder.SupportsDecoder("vc1_qsv"))
{
return "-c:v vc1_qsv ";
}
break;
}
}
}
// leave blank so ffmpeg will decide
2015-09-20 02:06:56 +00:00
return null;
}
2013-02-27 04:19:05 +00:00
/// <summary>
/// Gets the input argument.
/// </summary>
2013-12-19 21:51:32 +00:00
/// <param name="state">The state.</param>
2013-02-27 04:19:05 +00:00
/// <returns>System.String.</returns>
2015-03-28 20:22:27 +00:00
protected string GetInputArgument(StreamState state)
2014-12-20 06:06:27 +00:00
{
2015-09-20 02:06:56 +00:00
var arg = string.Format("-i {0}", GetInputPathArgument(state));
2014-12-20 06:06:27 +00:00
if (state.SubtitleStream != null)
{
if (state.SubtitleStream.IsExternal && !state.SubtitleStream.IsTextSubtitleStream)
{
2015-01-03 19:38:22 +00:00
arg += " -i \"" + state.SubtitleStream.Path + "\"";
2014-12-20 06:06:27 +00:00
}
}
return arg.Trim();
2014-12-20 06:06:27 +00:00
}
2015-03-28 20:22:27 +00:00
private string GetInputPathArgument(StreamState state)
2013-02-27 04:19:05 +00:00
{
var protocol = state.InputProtocol;
2015-03-28 20:22:27 +00:00
var mediaPath = state.MediaPath ?? string.Empty;
2015-03-28 20:22:27 +00:00
var inputPath = new[] { mediaPath };
2013-12-19 21:51:32 +00:00
if (state.IsInputVideo)
{
2013-12-19 21:51:32 +00:00
if (!(state.VideoType == VideoType.Iso && state.IsoMount == null))
2013-05-21 06:17:07 +00:00
{
2015-09-24 17:50:49 +00:00
inputPath = MediaEncoderHelpers.GetInputArgument(FileSystem, mediaPath, state.InputProtocol, state.IsoMount, state.PlayableStreamFileNames);
2013-05-21 06:17:07 +00:00
}
}
return MediaEncoder.GetInputArgument(inputPath, protocol);
2013-02-27 04:19:05 +00:00
}
2014-06-28 19:35:30 +00:00
private async Task AcquireResources(StreamState state, CancellationTokenSource cancellationTokenSource)
{
if (state.VideoType == VideoType.Iso && state.IsoType.HasValue && IsoManager.CanMount(state.MediaPath))
{
state.IsoMount = await IsoManager.Mount(state.MediaPath, cancellationTokenSource.Token).ConfigureAwait(false);
}
2015-08-24 12:54:10 +00:00
if (state.MediaSource.RequiresOpening && string.IsNullOrWhiteSpace(state.Request.LiveStreamId))
2014-06-28 19:35:30 +00:00
{
2015-03-29 16:45:16 +00:00
var liveStreamResponse = await MediaSourceManager.OpenLiveStream(new LiveStreamRequest
{
OpenToken = state.MediaSource.OpenToken
}, false, cancellationTokenSource.Token).ConfigureAwait(false);
2014-06-28 19:35:30 +00:00
2015-03-29 16:45:16 +00:00
AttachMediaSourceInfo(state, liveStreamResponse.MediaSource, state.VideoRequest, state.RequestedUrl);
2014-06-28 19:35:30 +00:00
2015-03-28 20:22:27 +00:00
if (state.VideoRequest != null)
2014-06-28 19:35:30 +00:00
{
2015-03-28 20:22:27 +00:00
TryStreamCopy(state, state.VideoRequest);
2014-08-15 16:35:41 +00:00
}
2015-03-29 04:56:39 +00:00
}
2014-08-15 16:35:41 +00:00
2015-03-29 04:56:39 +00:00
if (state.MediaSource.BufferMs.HasValue)
{
await Task.Delay(state.MediaSource.BufferMs.Value, cancellationTokenSource.Token).ConfigureAwait(false);
2014-06-28 19:35:30 +00:00
}
}
2013-02-27 04:19:05 +00:00
/// <summary>
/// Starts the FFMPEG.
/// </summary>
/// <param name="state">The state.</param>
/// <param name="outputPath">The output path.</param>
2014-06-02 19:32:41 +00:00
/// <param name="cancellationTokenSource">The cancellation token source.</param>
2014-10-16 03:26:39 +00:00
/// <param name="workingDirectory">The working directory.</param>
2013-02-27 04:19:05 +00:00
/// <returns>Task.</returns>
2014-12-20 06:06:27 +00:00
protected async Task<TranscodingJob> StartFfMpeg(StreamState state,
string outputPath,
2014-10-16 03:26:39 +00:00
CancellationTokenSource cancellationTokenSource,
string workingDirectory = null)
2013-02-27 04:19:05 +00:00
{
2015-09-13 21:32:02 +00:00
FileSystem.CreateDirectory(Path.GetDirectoryName(outputPath));
2013-06-04 16:48:23 +00:00
2014-06-28 19:35:30 +00:00
await AcquireResources(state, cancellationTokenSource).ConfigureAwait(false);
2013-02-27 04:19:05 +00:00
2014-09-03 02:30:24 +00:00
var transcodingId = Guid.NewGuid().ToString("N");
2015-03-28 20:22:27 +00:00
var commandLineArgs = GetCommandLineArguments(outputPath, state, true);
2014-12-21 19:40:37 +00:00
if (ApiEntryPoint.Instance.GetEncodingOptions().EnableDebugLogging)
{
commandLineArgs = "-loglevel debug " + commandLineArgs;
}
2013-02-27 04:19:05 +00:00
var process = new Process
{
StartInfo = new ProcessStartInfo
{
CreateNoWindow = true,
UseShellExecute = false,
// Must consume both stdout and stderr or deadlocks may occur
RedirectStandardOutput = true,
RedirectStandardError = true,
2014-06-20 04:50:30 +00:00
RedirectStandardInput = true,
2013-02-27 04:19:05 +00:00
FileName = MediaEncoder.EncoderPath,
Arguments = commandLineArgs,
2013-02-27 04:19:05 +00:00
WindowStyle = ProcessWindowStyle.Hidden,
ErrorDialog = false
2013-02-27 04:19:05 +00:00
},
EnableRaisingEvents = true
};
2014-10-16 03:26:39 +00:00
if (!string.IsNullOrWhiteSpace(workingDirectory))
{
process.StartInfo.WorkingDirectory = workingDirectory;
}
2014-09-03 02:30:24 +00:00
var transcodingJob = ApiEntryPoint.Instance.OnTranscodeBeginning(outputPath,
2015-03-29 18:31:28 +00:00
state.Request.PlaySessionId,
2015-04-20 18:04:02 +00:00
state.MediaSource.LiveStreamId,
2014-09-03 02:30:24 +00:00
transcodingId,
TranscodingJobType,
process,
state.Request.DeviceId,
state,
cancellationTokenSource);
2013-02-27 04:19:05 +00:00
2014-04-03 22:50:04 +00:00
var commandLineLogMessage = process.StartInfo.FileName + " " + process.StartInfo.Arguments;
Logger.Info(commandLineLogMessage);
2013-02-27 04:19:05 +00:00
2014-04-09 02:12:17 +00:00
var logFilePath = Path.Combine(ServerConfigurationManager.ApplicationPaths.LogDirectoryPath, "transcode-" + Guid.NewGuid() + ".txt");
2015-09-13 21:32:02 +00:00
FileSystem.CreateDirectory(Path.GetDirectoryName(logFilePath));
2013-02-27 04:19:05 +00:00
// FFMpeg writes debug/error info to stderr. This is useful when debugging so let's put it in the log directory.
state.LogFileStream = FileSystem.GetFileStream(logFilePath, FileMode.Create, FileAccess.Write, FileShare.Read, true);
2013-02-27 04:19:05 +00:00
2015-05-04 17:44:25 +00:00
var commandLineLogMessageBytes = Encoding.UTF8.GetBytes(Request.AbsoluteUri + Environment.NewLine + Environment.NewLine + JsonSerializer.SerializeToString(state.MediaSource) + Environment.NewLine + Environment.NewLine + commandLineLogMessage + Environment.NewLine + Environment.NewLine);
2014-06-02 19:32:41 +00:00
await state.LogFileStream.WriteAsync(commandLineLogMessageBytes, 0, commandLineLogMessageBytes.Length, cancellationTokenSource.Token).ConfigureAwait(false);
2014-04-03 22:50:04 +00:00
2014-09-03 02:30:24 +00:00
process.Exited += (sender, args) => OnFfMpegProcessExited(process, transcodingJob, state);
2013-02-27 04:19:05 +00:00
try
{
process.Start();
}
catch (Exception ex)
2013-02-27 04:19:05 +00:00
{
Logger.ErrorException("Error starting ffmpeg", ex);
ApiEntryPoint.Instance.OnTranscodeFailedToStart(outputPath, TranscodingJobType, state);
2013-02-27 04:19:05 +00:00
throw;
}
// MUST read both stdout and stderr asynchronously or a deadlock may occurr
process.BeginOutputReadLine();
// Important - don't await the log task or we won't be able to kill ffmpeg when the user stops playback
2014-09-03 02:30:24 +00:00
StartStreamingLog(transcodingJob, state, process.StandardError.BaseStream, state.LogFileStream);
2013-02-27 04:19:05 +00:00
// Wait for the file to exist before proceeeding
2015-09-13 21:32:02 +00:00
while (!FileSystem.FileExists(state.WaitForPath ?? outputPath) && !transcodingJob.HasExited)
2013-02-27 04:19:05 +00:00
{
2014-06-02 19:32:41 +00:00
await Task.Delay(100, cancellationTokenSource.Token).ConfigureAwait(false);
2013-02-27 04:19:05 +00:00
}
2014-09-03 02:30:24 +00:00
2014-10-15 04:11:40 +00:00
if (state.IsInputVideo && transcodingJob.Type == TranscodingJobType.Progressive)
2014-10-15 00:04:44 +00:00
{
await Task.Delay(1000, cancellationTokenSource.Token).ConfigureAwait(false);
if (state.ReadInputAtNativeFramerate)
{
2014-11-11 03:41:55 +00:00
await Task.Delay(1500, cancellationTokenSource.Token).ConfigureAwait(false);
2014-10-15 00:04:44 +00:00
}
}
2015-02-28 18:47:05 +00:00
StartThrottler(state, transcodingJob);
2014-09-03 02:30:24 +00:00
return transcodingJob;
2013-02-27 04:19:05 +00:00
}
2015-02-28 18:47:05 +00:00
private void StartThrottler(StreamState state, TranscodingJob transcodingJob)
{
2015-05-25 17:32:22 +00:00
if (EnableThrottling(state) && state.InputProtocol == MediaProtocol.File &&
2015-02-28 18:47:05 +00:00
state.RunTimeTicks.HasValue &&
state.VideoType == VideoType.VideoFile &&
!string.Equals(state.OutputVideoCodec, "copy", StringComparison.OrdinalIgnoreCase))
{
if (state.RunTimeTicks.Value >= TimeSpan.FromMinutes(5).Ticks && state.IsInputVideo)
{
transcodingJob.TranscodingThrottler = state.TranscodingThrottler = new TranscodingThrottler(transcodingJob, Logger, ServerConfigurationManager);
2015-02-28 18:47:05 +00:00
state.TranscodingThrottler.Start();
}
}
}
2015-05-25 17:32:22 +00:00
protected virtual bool EnableThrottling(StreamState state)
2015-05-19 19:15:40 +00:00
{
2015-05-25 17:32:22 +00:00
return true;
2015-05-19 19:15:40 +00:00
}
2014-09-03 02:30:24 +00:00
private async void StartStreamingLog(TranscodingJob transcodingJob, StreamState state, Stream source, Stream target)
{
try
{
using (var reader = new StreamReader(source))
{
while (!reader.EndOfStream)
{
var line = await reader.ReadLineAsync().ConfigureAwait(false);
2014-09-03 02:30:24 +00:00
ParseLogLine(line, transcodingJob, state);
var bytes = Encoding.UTF8.GetBytes(Environment.NewLine + line);
await target.WriteAsync(bytes, 0, bytes.Length).ConfigureAwait(false);
2015-09-20 02:06:56 +00:00
await target.FlushAsync().ConfigureAwait(false);
}
}
}
2015-05-07 22:27:01 +00:00
catch (ObjectDisposedException)
{
// Don't spam the log. This doesn't seem to throw in windows, but sometimes under linux
}
catch (Exception ex)
{
Logger.ErrorException("Error reading ffmpeg log", ex);
}
}
2014-09-03 02:30:24 +00:00
private void ParseLogLine(string line, TranscodingJob transcodingJob, StreamState state)
{
float? framerate = null;
double? percent = null;
2014-09-03 02:30:24 +00:00
TimeSpan? transcodingPosition = null;
long? bytesTranscoded = null;
var parts = line.Split(' ');
var totalMs = state.RunTimeTicks.HasValue
? TimeSpan.FromTicks(state.RunTimeTicks.Value).TotalMilliseconds
: 0;
var startMs = state.Request.StartTimeTicks.HasValue
? TimeSpan.FromTicks(state.Request.StartTimeTicks.Value).TotalMilliseconds
: 0;
for (var i = 0; i < parts.Length; i++)
{
var part = parts[i];
if (string.Equals(part, "fps=", StringComparison.OrdinalIgnoreCase) &&
(i + 1 < parts.Length))
{
var rate = parts[i + 1];
float val;
if (float.TryParse(rate, NumberStyles.Any, UsCulture, out val))
{
framerate = val;
}
}
else if (state.RunTimeTicks.HasValue &&
part.StartsWith("time=", StringComparison.OrdinalIgnoreCase))
{
var time = part.Split(new[] { '=' }, 2).Last();
TimeSpan val;
if (TimeSpan.TryParse(time, UsCulture, out val))
{
var currentMs = startMs + val.TotalMilliseconds;
var percentVal = currentMs / totalMs;
percent = 100 * percentVal;
2014-09-03 02:30:24 +00:00
transcodingPosition = val;
}
}
else if (part.StartsWith("size=", StringComparison.OrdinalIgnoreCase))
{
var size = part.Split(new[] { '=' }, 2).Last();
int? scale = null;
if (size.IndexOf("kb", StringComparison.OrdinalIgnoreCase) != -1)
{
scale = 1024;
size = size.Replace("kb", string.Empty, StringComparison.OrdinalIgnoreCase);
}
if (scale.HasValue)
{
long val;
2014-12-20 06:06:27 +00:00
2014-09-03 02:30:24 +00:00
if (long.TryParse(size, NumberStyles.Any, UsCulture, out val))
{
bytesTranscoded = val * scale.Value;
}
}
}
}
if (framerate.HasValue || percent.HasValue)
{
2014-09-03 02:30:24 +00:00
ApiEntryPoint.Instance.ReportTranscodingProgress(transcodingJob, state, transcodingPosition, framerate, percent, bytesTranscoded);
}
}
private int? GetVideoBitrateParamValue(VideoStreamRequest request, MediaStream videoStream)
2013-08-30 02:13:58 +00:00
{
var bitrate = request.VideoBitRate;
2014-02-03 20:37:18 +00:00
if (videoStream != null)
2014-02-03 20:37:18 +00:00
{
var isUpscaling = request.Height.HasValue && videoStream.Height.HasValue &&
request.Height.Value > videoStream.Height.Value;
2014-02-03 20:37:18 +00:00
if (request.Width.HasValue && videoStream.Width.HasValue &&
request.Width.Value > videoStream.Width.Value)
2014-02-03 20:37:18 +00:00
{
isUpscaling = true;
}
2014-02-03 20:37:18 +00:00
// Don't allow bitrate increases unless upscaling
if (!isUpscaling)
{
if (bitrate.HasValue && videoStream.BitRate.HasValue)
2014-02-03 20:37:18 +00:00
{
bitrate = Math.Min(bitrate.Value, videoStream.BitRate.Value);
2014-02-03 20:37:18 +00:00
}
}
}
return bitrate;
2013-08-30 02:13:58 +00:00
}
2014-02-02 14:47:00 +00:00
protected string GetVideoBitrateParam(StreamState state, string videoCodec, bool isHls)
{
var bitrate = state.OutputVideoBitrate;
2014-02-02 14:47:00 +00:00
if (bitrate.HasValue)
{
if (string.Equals(videoCodec, "libvpx", StringComparison.OrdinalIgnoreCase))
{
// With vpx when crf is used, b:v becomes a max rate
// https://trac.ffmpeg.org/wiki/vpxEncodingGuide. But higher bitrate source files -b:v causes judder so limite the bitrate but dont allow it to "saturate" the bitrate. So dont contrain it down just up.
return string.Format(" -maxrate:v {0} -bufsize:v ({0}*2) -b:v {0}", bitrate.Value.ToString(UsCulture));
2014-02-02 14:47:00 +00:00
}
2014-02-02 14:47:00 +00:00
if (string.Equals(videoCodec, "msmpeg4", StringComparison.OrdinalIgnoreCase))
{
return string.Format(" -b:v {0}", bitrate.Value.ToString(UsCulture));
}
2015-10-05 03:24:24 +00:00
// h264
if (isHls)
2015-01-14 04:02:57 +00:00
{
2015-10-05 03:24:24 +00:00
return string.Format(" -b:v {0} -maxrate {0} -bufsize {1}",
bitrate.Value.ToString(UsCulture),
(bitrate.Value * 2).ToString(UsCulture));
}
2014-04-01 22:23:07 +00:00
2015-10-05 03:24:24 +00:00
return string.Format(" -b:v {0}", bitrate.Value.ToString(UsCulture));
2014-02-02 14:47:00 +00:00
}
return string.Empty;
}
private int? GetAudioBitrateParam(StreamRequest request, MediaStream audioStream)
2013-08-30 02:13:58 +00:00
{
if (request.AudioBitRate.HasValue)
2013-08-30 02:13:58 +00:00
{
// Make sure we don't request a bitrate higher than the source
var currentBitrate = audioStream == null ? request.AudioBitRate.Value : audioStream.BitRate ?? request.AudioBitRate.Value;
2013-08-30 02:13:58 +00:00
2014-06-24 21:45:21 +00:00
return request.AudioBitRate.Value;
//return Math.Min(currentBitrate, request.AudioBitRate.Value);
2013-08-30 02:13:58 +00:00
}
return null;
}
2013-05-01 20:07:20 +00:00
/// <summary>
/// Gets the user agent param.
/// </summary>
2014-06-02 19:32:41 +00:00
/// <param name="state">The state.</param>
2013-05-01 20:07:20 +00:00
/// <returns>System.String.</returns>
2014-06-02 19:32:41 +00:00
private string GetUserAgentParam(StreamState state)
2013-05-17 18:05:49 +00:00
{
2014-06-04 03:34:36 +00:00
string useragent = null;
2014-06-04 19:40:05 +00:00
state.RemoteHttpHeaders.TryGetValue("User-Agent", out useragent);
2013-05-17 18:05:49 +00:00
2014-06-02 19:32:41 +00:00
if (!string.IsNullOrWhiteSpace(useragent))
2013-05-17 18:05:49 +00:00
{
return "-user-agent \"" + useragent + "\"";
}
return string.Empty;
}
2013-02-27 04:19:05 +00:00
/// <summary>
/// Processes the exited.
/// </summary>
/// <param name="process">The process.</param>
2014-09-03 02:30:24 +00:00
/// <param name="job">The job.</param>
2013-02-27 04:19:05 +00:00
/// <param name="state">The state.</param>
2014-09-03 02:30:24 +00:00
private void OnFfMpegProcessExited(Process process, TranscodingJob job, StreamState state)
2013-02-27 04:19:05 +00:00
{
2014-06-26 17:04:11 +00:00
if (job != null)
{
job.HasExited = true;
}
2014-06-20 04:50:30 +00:00
Logger.Debug("Disposing stream resources");
2014-04-05 15:02:50 +00:00
state.Dispose();
2014-01-03 04:58:22 +00:00
2013-02-27 04:19:05 +00:00
try
{
Logger.Info("FFMpeg exited with code {0}", process.ExitCode);
2013-02-27 04:19:05 +00:00
}
catch
{
2014-06-20 04:50:30 +00:00
Logger.Error("FFMpeg exited with an error.");
2013-02-27 04:19:05 +00:00
}
2014-06-20 04:50:30 +00:00
// This causes on exited to be called twice:
//try
//{
// // Dispose the process
// process.Dispose();
//}
//catch (Exception ex)
//{
// Logger.ErrorException("Error disposing ffmpeg.", ex);
//}
2013-02-27 04:19:05 +00:00
}
2014-01-24 18:09:50 +00:00
protected double? GetFramerateParam(StreamState state)
{
2014-03-24 17:54:45 +00:00
if (state.VideoRequest != null)
2014-01-24 18:09:50 +00:00
{
2014-03-24 17:54:45 +00:00
if (state.VideoRequest.Framerate.HasValue)
{
return state.VideoRequest.Framerate.Value;
}
2014-01-24 18:09:50 +00:00
2014-08-24 15:48:06 +00:00
var maxrate = state.VideoRequest.MaxFramerate;
2014-01-24 18:09:50 +00:00
2014-08-24 15:48:06 +00:00
if (maxrate.HasValue && state.VideoStream != null)
2014-01-24 18:09:50 +00:00
{
2014-03-24 17:54:45 +00:00
var contentRate = state.VideoStream.AverageFrameRate ?? state.VideoStream.RealFrameRate;
2014-08-24 15:48:06 +00:00
if (contentRate.HasValue && contentRate.Value > maxrate.Value)
2014-03-24 17:54:45 +00:00
{
return maxrate;
}
2014-01-24 18:09:50 +00:00
}
}
return null;
}
2014-02-13 05:11:54 +00:00
/// <summary>
/// Parses the parameters.
/// </summary>
/// <param name="request">The request.</param>
private void ParseParams(StreamRequest request)
{
var vals = request.Params.Split(';');
var videoRequest = request as VideoStreamRequest;
for (var i = 0; i < vals.Length; i++)
{
var val = vals[i];
if (string.IsNullOrWhiteSpace(val))
{
continue;
}
if (i == 0)
{
2014-03-26 15:06:48 +00:00
request.DeviceProfileId = val;
}
2014-03-25 05:25:03 +00:00
else if (i == 1)
2014-03-23 05:10:33 +00:00
{
2014-03-26 15:06:48 +00:00
request.DeviceId = val;
2014-03-23 05:10:33 +00:00
}
2014-03-25 05:25:03 +00:00
else if (i == 2)
2014-03-23 17:18:24 +00:00
{
2014-03-26 15:06:48 +00:00
request.MediaSourceId = val;
2014-03-23 17:18:24 +00:00
}
2014-03-25 05:25:03 +00:00
else if (i == 3)
2014-03-26 15:06:48 +00:00
{
request.Static = string.Equals("true", val, StringComparison.OrdinalIgnoreCase);
}
else if (i == 4)
2014-02-13 05:11:54 +00:00
{
if (videoRequest != null)
{
2014-03-23 20:07:02 +00:00
videoRequest.VideoCodec = val;
2014-02-13 05:11:54 +00:00
}
}
2014-03-26 15:06:48 +00:00
else if (i == 5)
2014-02-13 05:11:54 +00:00
{
2014-03-23 20:07:02 +00:00
request.AudioCodec = val;
2014-02-13 05:11:54 +00:00
}
2014-03-26 15:06:48 +00:00
else if (i == 6)
2014-02-13 05:11:54 +00:00
{
if (videoRequest != null)
{
videoRequest.AudioStreamIndex = int.Parse(val, UsCulture);
}
}
2014-03-26 15:06:48 +00:00
else if (i == 7)
2014-02-13 05:11:54 +00:00
{
if (videoRequest != null)
{
videoRequest.SubtitleStreamIndex = int.Parse(val, UsCulture);
}
}
2014-03-26 15:06:48 +00:00
else if (i == 8)
2014-02-13 05:11:54 +00:00
{
if (videoRequest != null)
{
videoRequest.VideoBitRate = int.Parse(val, UsCulture);
}
}
2014-03-26 15:06:48 +00:00
else if (i == 9)
2014-02-13 05:11:54 +00:00
{
request.AudioBitRate = int.Parse(val, UsCulture);
}
2014-03-26 15:06:48 +00:00
else if (i == 10)
2014-02-13 05:11:54 +00:00
{
2014-03-23 05:10:33 +00:00
request.MaxAudioChannels = int.Parse(val, UsCulture);
2014-02-13 05:11:54 +00:00
}
2014-03-26 15:06:48 +00:00
else if (i == 11)
{
if (videoRequest != null)
{
2014-06-23 16:05:19 +00:00
videoRequest.MaxFramerate = float.Parse(val, UsCulture);
}
}
2014-03-26 15:06:48 +00:00
else if (i == 12)
{
if (videoRequest != null)
{
2014-03-28 04:24:11 +00:00
videoRequest.MaxWidth = int.Parse(val, UsCulture);
}
}
2014-03-26 15:06:48 +00:00
else if (i == 13)
2014-03-24 17:54:45 +00:00
{
if (videoRequest != null)
{
2014-03-28 04:24:11 +00:00
videoRequest.MaxHeight = int.Parse(val, UsCulture);
2014-03-24 17:54:45 +00:00
}
}
2014-03-26 15:06:48 +00:00
else if (i == 14)
2014-03-24 17:54:45 +00:00
{
2014-03-30 19:05:10 +00:00
request.StartTimeTicks = long.Parse(val, UsCulture);
2014-03-24 17:54:45 +00:00
}
2014-03-26 15:06:48 +00:00
else if (i == 15)
2014-03-28 04:24:11 +00:00
{
if (videoRequest != null)
{
videoRequest.Level = val;
}
}
2014-09-18 04:50:21 +00:00
else if (i == 16)
2014-09-23 04:05:29 +00:00
{
if (videoRequest != null)
{
videoRequest.MaxRefFrames = int.Parse(val, UsCulture);
}
}
2015-11-27 04:33:20 +00:00
else if (i == 17)
2014-09-23 04:05:29 +00:00
{
if (videoRequest != null)
{
videoRequest.MaxVideoBitDepth = int.Parse(val, UsCulture);
}
}
2015-11-27 04:33:20 +00:00
else if (i == 18)
2014-10-09 22:22:04 +00:00
{
if (videoRequest != null)
{
videoRequest.Profile = val;
}
}
2015-11-27 04:33:20 +00:00
else if (i == 19)
2014-11-12 04:51:40 +00:00
{
if (videoRequest != null)
{
videoRequest.Cabac = string.Equals("true", val, StringComparison.OrdinalIgnoreCase);
}
}
2015-11-27 04:33:20 +00:00
else if (i == 20)
2015-03-23 17:19:21 +00:00
{
2015-03-29 18:31:28 +00:00
request.PlaySessionId = val;
2015-03-23 17:19:21 +00:00
}
2015-11-27 04:33:20 +00:00
else if (i == 21)
2015-04-12 16:46:29 +00:00
{
// api_key
}
2015-11-27 04:33:20 +00:00
else if (i == 22)
2015-03-29 18:16:40 +00:00
{
request.LiveStreamId = val;
}
2015-11-27 04:33:20 +00:00
else if (i == 23)
2015-04-24 20:06:37 +00:00
{
// Duplicating ItemId because of MediaMonkey
}
2014-02-13 05:11:54 +00:00
}
}
2014-04-01 22:23:07 +00:00
/// <summary>
/// Parses the dlna headers.
/// </summary>
/// <param name="request">The request.</param>
private void ParseDlnaHeaders(StreamRequest request)
{
if (!request.StartTimeTicks.HasValue)
{
var timeSeek = GetHeader("TimeSeekRange.dlna.org");
request.StartTimeTicks = ParseTimeSeekHeader(timeSeek);
}
}
/// <summary>
/// Parses the time seek header.
/// </summary>
private long? ParseTimeSeekHeader(string value)
{
if (string.IsNullOrWhiteSpace(value))
{
return null;
}
if (value.IndexOf("npt=", StringComparison.OrdinalIgnoreCase) != 0)
{
throw new ArgumentException("Invalid timeseek header");
}
value = value.Substring(4).Split(new[] { '-' }, 2)[0];
if (value.IndexOf(':') == -1)
{
// Parses npt times in the format of '417.33'
double seconds;
if (double.TryParse(value, NumberStyles.Any, UsCulture, out seconds))
{
return TimeSpan.FromSeconds(seconds).Ticks;
}
throw new ArgumentException("Invalid timeseek header");
}
// Parses npt times in the format of '10:19:25.7'
var tokens = value.Split(new[] { ':' }, 3);
double secondsSum = 0;
var timeFactor = 3600;
foreach (var time in tokens)
{
double digit;
if (double.TryParse(time, NumberStyles.Any, UsCulture, out digit))
{
secondsSum += (digit * timeFactor);
}
else
{
throw new ArgumentException("Invalid timeseek header");
}
timeFactor /= 60;
}
return TimeSpan.FromSeconds(secondsSum).Ticks;
}
2013-02-27 04:19:05 +00:00
/// <summary>
/// Gets the state.
/// </summary>
/// <param name="request">The request.</param>
2013-12-21 18:37:34 +00:00
/// <param name="cancellationToken">The cancellation token.</param>
2013-02-27 04:19:05 +00:00
/// <returns>StreamState.</returns>
2013-12-21 18:37:34 +00:00
protected async Task<StreamState> GetState(StreamRequest request, CancellationToken cancellationToken)
2013-02-27 04:19:05 +00:00
{
2014-04-01 22:23:07 +00:00
ParseDlnaHeaders(request);
2014-02-13 05:11:54 +00:00
if (!string.IsNullOrWhiteSpace(request.Params))
{
ParseParams(request);
}
2013-12-07 15:52:38 +00:00
var url = Request.PathInfo;
2013-02-27 04:44:41 +00:00
2014-03-23 20:07:02 +00:00
if (string.IsNullOrEmpty(request.AudioCodec))
2013-02-27 04:44:41 +00:00
{
request.AudioCodec = InferAudioCodec(url);
}
2015-03-28 20:22:27 +00:00
var state = new StreamState(MediaSourceManager, Logger)
2013-02-27 04:19:05 +00:00
{
Request = request,
2013-12-21 18:37:34 +00:00
RequestedUrl = url
2013-02-27 04:19:05 +00:00
};
2013-03-09 02:34:54 +00:00
2014-04-10 15:06:54 +00:00
if (!string.IsNullOrWhiteSpace(request.AudioCodec))
{
state.SupportedAudioCodecs = request.AudioCodec.Split(',').Where(i => !string.IsNullOrWhiteSpace(i)).ToList();
state.Request.AudioCodec = state.SupportedAudioCodecs.FirstOrDefault();
}
2014-06-02 19:32:41 +00:00
var item = LibraryManager.GetItemById(request.Id);
2013-12-21 18:37:34 +00:00
2015-03-28 20:22:27 +00:00
state.IsInputVideo = string.Equals(item.MediaType, MediaType.Video, StringComparison.OrdinalIgnoreCase);
2014-05-18 19:58:42 +00:00
2015-03-17 03:48:05 +00:00
var archivable = item as IArchivable;
state.IsInputArchive = archivable != null && archivable.IsArchive;
2014-06-28 19:35:30 +00:00
2015-04-07 17:51:14 +00:00
MediaSourceInfo mediaSource;
2015-03-29 04:56:39 +00:00
if (string.IsNullOrWhiteSpace(request.LiveStreamId))
{
2015-04-09 05:20:23 +00:00
var mediaSources = (await MediaSourceManager.GetPlayackMediaSources(request.Id, null, false, new[] { MediaType.Audio, MediaType.Video }, cancellationToken).ConfigureAwait(false)).ToList();
2015-03-29 04:56:39 +00:00
mediaSource = string.IsNullOrEmpty(request.MediaSourceId)
? mediaSources.First()
2015-04-07 17:51:14 +00:00
: mediaSources.FirstOrDefault(i => string.Equals(i.Id, request.MediaSourceId));
if (mediaSource == null && string.Equals(request.Id, request.MediaSourceId, StringComparison.OrdinalIgnoreCase))
{
mediaSource = mediaSources.First();
}
2015-03-29 04:56:39 +00:00
}
else
{
mediaSource = await MediaSourceManager.GetLiveStream(request.LiveStreamId, cancellationToken).ConfigureAwait(false);
}
2013-12-19 21:51:32 +00:00
2014-06-11 19:31:33 +00:00
var videoRequest = request as VideoStreamRequest;
2013-12-06 03:39:44 +00:00
2015-03-28 20:22:27 +00:00
AttachMediaSourceInfo(state, mediaSource, videoRequest, url);
2013-03-11 03:44:22 +00:00
var container = Path.GetExtension(state.RequestedUrl);
if (string.IsNullOrEmpty(container))
{
2014-12-20 06:06:27 +00:00
container = request.Static ?
2014-10-16 03:26:39 +00:00
state.InputContainer :
(Path.GetExtension(GetOutputFilePath(state)) ?? string.Empty).TrimStart('.');
}
state.OutputContainer = (container ?? string.Empty).TrimStart('.');
state.OutputAudioBitrate = GetAudioBitrateParam(state.Request, state.AudioStream);
state.OutputAudioSampleRate = request.AudioSampleRate;
2015-06-03 03:15:46 +00:00
state.OutputAudioCodec = state.Request.AudioCodec;
2014-06-06 04:56:47 +00:00
state.OutputAudioChannels = GetNumAudioChannelsParam(state.Request, state.AudioStream, state.OutputAudioCodec);
2014-06-10 17:36:06 +00:00
2014-04-09 02:12:17 +00:00
if (videoRequest != null)
2014-04-02 04:10:46 +00:00
{
2015-06-03 03:15:46 +00:00
state.OutputVideoCodec = state.VideoRequest.VideoCodec;
state.OutputVideoBitrate = GetVideoBitrateParamValue(state.VideoRequest, state.VideoStream);
2014-10-06 23:58:46 +00:00
if (state.OutputVideoBitrate.HasValue)
{
var resolution = ResolutionNormalizer.Normalize(state.OutputVideoBitrate.Value,
state.OutputVideoCodec,
videoRequest.MaxWidth,
videoRequest.MaxHeight);
videoRequest.MaxWidth = resolution.MaxWidth;
videoRequest.MaxHeight = resolution.MaxHeight;
}
2014-06-23 16:05:19 +00:00
}
ApplyDeviceProfileSettings(state);
2014-06-23 16:05:19 +00:00
if (videoRequest != null)
{
2015-03-28 20:22:27 +00:00
TryStreamCopy(state, videoRequest);
2014-04-06 17:53:23 +00:00
}
state.OutputFilePath = GetOutputFilePath(state);
2013-03-09 02:34:54 +00:00
return state;
2013-02-27 04:19:05 +00:00
}
2013-02-27 04:44:41 +00:00
2015-03-28 20:22:27 +00:00
private void TryStreamCopy(StreamState state, VideoStreamRequest videoRequest)
{
if (state.VideoStream != null && CanStreamCopyVideo(videoRequest, state.VideoStream))
{
state.OutputVideoCodec = "copy";
}
if (state.AudioStream != null && CanStreamCopyAudio(videoRequest, state.AudioStream, state.SupportedAudioCodecs))
{
state.OutputAudioCodec = "copy";
}
}
private void AttachMediaSourceInfo(StreamState state,
2015-03-20 05:40:51 +00:00
MediaSourceInfo mediaSource,
2014-10-15 04:11:40 +00:00
VideoStreamRequest videoRequest,
string requestedUrl)
{
2015-03-28 20:22:27 +00:00
state.MediaPath = mediaSource.Path;
state.InputProtocol = mediaSource.Protocol;
state.InputContainer = mediaSource.Container;
state.InputFileSize = mediaSource.Size;
state.InputBitrate = mediaSource.Bitrate;
state.RunTimeTicks = mediaSource.RunTimeTicks;
state.RemoteHttpHeaders = mediaSource.RequiredHttpHeaders;
2015-03-29 04:56:39 +00:00
2015-03-28 20:22:27 +00:00
if (mediaSource.VideoType.HasValue)
{
state.VideoType = mediaSource.VideoType.Value;
}
state.IsoType = mediaSource.IsoType;
state.PlayableStreamFileNames = mediaSource.PlayableStreamFileNames.ToList();
if (mediaSource.Timestamp.HasValue)
{
state.InputTimestamp = mediaSource.Timestamp.Value;
}
2015-03-29 04:56:39 +00:00
2014-10-15 04:11:40 +00:00
state.InputProtocol = mediaSource.Protocol;
state.MediaPath = mediaSource.Path;
state.RunTimeTicks = mediaSource.RunTimeTicks;
state.RemoteHttpHeaders = mediaSource.RequiredHttpHeaders;
state.InputBitrate = mediaSource.Bitrate;
state.InputFileSize = mediaSource.Size;
2014-10-25 18:32:58 +00:00
state.ReadInputAtNativeFramerate = mediaSource.ReadAtNativeFramerate;
2014-10-15 04:11:40 +00:00
2015-03-28 20:22:27 +00:00
if (state.ReadInputAtNativeFramerate ||
mediaSource.Protocol == MediaProtocol.File && string.Equals(mediaSource.Container, "wtv", StringComparison.OrdinalIgnoreCase))
2014-12-19 04:20:07 +00:00
{
state.OutputAudioSync = "1000";
state.InputVideoSync = "-1";
state.InputAudioSync = "1";
}
2015-06-04 20:27:46 +00:00
if (string.Equals(mediaSource.Container, "wma", StringComparison.OrdinalIgnoreCase))
{
// Seeing some stuttering when transcoding wma to audio-only HLS
state.InputAudioSync = "1";
}
2015-03-28 20:22:27 +00:00
var mediaStreams = mediaSource.MediaStreams;
2014-12-20 06:06:27 +00:00
2014-06-01 19:41:35 +00:00
if (videoRequest != null)
{
if (string.IsNullOrEmpty(videoRequest.VideoCodec))
{
videoRequest.VideoCodec = InferVideoCodec(requestedUrl);
}
state.VideoStream = GetMediaStream(mediaStreams, videoRequest.VideoStreamIndex, MediaStreamType.Video);
state.SubtitleStream = GetMediaStream(mediaStreams, videoRequest.SubtitleStreamIndex, MediaStreamType.Subtitle, false);
state.AudioStream = GetMediaStream(mediaStreams, videoRequest.AudioStreamIndex, MediaStreamType.Audio);
2014-06-12 02:38:40 +00:00
if (state.SubtitleStream != null && !state.SubtitleStream.IsExternal)
{
state.InternalSubtitleStreamOffset = mediaStreams.Where(i => i.Type == MediaStreamType.Subtitle && !i.IsExternal).ToList().IndexOf(state.SubtitleStream);
}
2014-06-01 19:41:35 +00:00
if (state.VideoStream != null && state.VideoStream.IsInterlaced)
{
state.DeInterlace = true;
}
EnforceResolutionLimit(state, videoRequest);
}
else
{
state.AudioStream = GetMediaStream(mediaStreams, null, MediaStreamType.Audio, true);
}
2015-03-28 20:22:27 +00:00
state.MediaSource = mediaSource;
2014-06-01 19:41:35 +00:00
}
2015-08-27 15:58:07 +00:00
protected virtual bool CanStreamCopyVideo(VideoStreamRequest request, MediaStream videoStream)
2014-04-02 04:10:46 +00:00
{
if (videoStream.IsInterlaced)
{
return false;
}
2015-08-10 17:37:50 +00:00
if (videoStream.IsAnamorphic ?? false)
{
return false;
}
2014-06-20 05:31:32 +00:00
// Can't stream copy if we're burning in subtitles
if (request.SubtitleStreamIndex.HasValue)
{
2014-08-06 02:26:12 +00:00
if (request.SubtitleMethod == SubtitleDeliveryMethod.Encode)
{
return false;
}
2014-06-20 05:31:32 +00:00
}
2014-04-02 04:10:46 +00:00
// Source and target codecs must match
if (!string.Equals(request.VideoCodec, videoStream.Codec, StringComparison.OrdinalIgnoreCase))
{
return false;
}
// If client is requesting a specific video profile, it must match the source
2014-10-20 03:04:45 +00:00
if (!string.IsNullOrEmpty(request.Profile))
2014-04-02 04:10:46 +00:00
{
2014-10-20 03:04:45 +00:00
if (string.IsNullOrEmpty(videoStream.Profile))
{
return false;
}
if (!string.Equals(request.Profile, videoStream.Profile, StringComparison.OrdinalIgnoreCase))
{
var currentScore = GetVideoProfileScore(videoStream.Profile);
var requestedScore = GetVideoProfileScore(request.Profile);
if (currentScore == -1 || currentScore > requestedScore)
{
return false;
}
}
2014-04-02 04:10:46 +00:00
}
// Video width must fall within requested value
if (request.MaxWidth.HasValue)
{
if (!videoStream.Width.HasValue || videoStream.Width.Value > request.MaxWidth.Value)
{
return false;
}
}
// Video height must fall within requested value
if (request.MaxHeight.HasValue)
{
if (!videoStream.Height.HasValue || videoStream.Height.Value > request.MaxHeight.Value)
{
return false;
}
}
// Video framerate must fall within requested value
var requestedFramerate = request.MaxFramerate ?? request.Framerate;
if (requestedFramerate.HasValue)
{
var videoFrameRate = videoStream.AverageFrameRate ?? videoStream.RealFrameRate;
if (!videoFrameRate.HasValue || videoFrameRate.Value > requestedFramerate.Value)
{
return false;
}
}
// Video bitrate must fall within requested value
if (request.VideoBitRate.HasValue)
{
if (!videoStream.BitRate.HasValue || videoStream.BitRate.Value > request.VideoBitRate.Value)
{
return false;
}
}
2014-09-23 04:05:29 +00:00
if (request.MaxVideoBitDepth.HasValue)
{
if (videoStream.BitDepth.HasValue && videoStream.BitDepth.Value > request.MaxVideoBitDepth.Value)
{
return false;
}
}
if (request.MaxRefFrames.HasValue)
{
if (videoStream.RefFrames.HasValue && videoStream.RefFrames.Value > request.MaxRefFrames.Value)
{
return false;
}
}
2014-04-02 04:10:46 +00:00
// If a specific level was requested, the source must match or be less than
if (!string.IsNullOrEmpty(request.Level))
{
double requestLevel;
if (double.TryParse(request.Level, NumberStyles.Any, UsCulture, out requestLevel))
{
if (!videoStream.Level.HasValue)
{
return false;
}
if (videoStream.Level.Value > requestLevel)
{
return false;
}
}
}
2014-11-12 04:51:40 +00:00
if (request.Cabac.HasValue && request.Cabac.Value)
{
if (videoStream.IsCabac.HasValue && !videoStream.IsCabac.Value)
{
return false;
}
}
return request.EnableAutoStreamCopy;
2014-04-02 04:10:46 +00:00
}
2014-10-20 03:04:45 +00:00
private int GetVideoProfileScore(string profile)
{
var list = new List<string>
{
"Constrained Baseline",
"Baseline",
"Extended",
"Main",
"High",
"Progressive High",
"Constrained High"
};
return Array.FindIndex(list.ToArray(), t => string.Equals(t, profile, StringComparison.OrdinalIgnoreCase));
}
2015-08-27 15:58:07 +00:00
protected virtual bool CanStreamCopyAudio(VideoStreamRequest request, MediaStream audioStream, List<string> supportedAudioCodecs)
2014-04-06 17:53:23 +00:00
{
// Source and target codecs must match
2014-04-10 15:06:54 +00:00
if (string.IsNullOrEmpty(audioStream.Codec) || !supportedAudioCodecs.Contains(audioStream.Codec, StringComparer.OrdinalIgnoreCase))
2014-04-06 17:53:23 +00:00
{
return false;
}
// Video bitrate must fall within requested value
if (request.AudioBitRate.HasValue)
{
2014-05-30 21:06:57 +00:00
if (!audioStream.BitRate.HasValue || audioStream.BitRate.Value <= 0)
{
return false;
}
if (audioStream.BitRate.Value > request.AudioBitRate.Value)
2014-04-06 17:53:23 +00:00
{
return false;
}
}
// Channels must fall within requested value
var channels = request.AudioChannels ?? request.MaxAudioChannels;
if (channels.HasValue)
{
2014-05-30 21:06:57 +00:00
if (!audioStream.Channels.HasValue || audioStream.Channels.Value <= 0)
{
return false;
}
if (audioStream.Channels.Value > channels.Value)
2014-04-06 17:53:23 +00:00
{
return false;
}
}
// Sample rate must fall within requested value
if (request.AudioSampleRate.HasValue)
{
2014-05-30 21:06:57 +00:00
if (!audioStream.SampleRate.HasValue || audioStream.SampleRate.Value <= 0)
{
return false;
}
if (audioStream.SampleRate.Value > request.AudioSampleRate.Value)
2014-04-06 17:53:23 +00:00
{
return false;
}
}
2014-10-04 01:42:38 +00:00
return request.EnableAutoStreamCopy;
2014-04-06 17:53:23 +00:00
}
2014-04-08 04:17:18 +00:00
2014-03-25 05:25:03 +00:00
private void ApplyDeviceProfileSettings(StreamState state)
{
2014-05-18 21:23:03 +00:00
var headers = new Dictionary<string, string>();
foreach (var key in Request.Headers.AllKeys)
{
headers[key] = Request.Headers[key];
}
2015-01-20 05:19:13 +00:00
if (!string.IsNullOrWhiteSpace(state.Request.DeviceProfileId))
{
state.DeviceProfile = DlnaManager.GetProfile(state.Request.DeviceProfileId);
}
else
{
if (!string.IsNullOrWhiteSpace(state.Request.DeviceId))
{
var caps = DeviceManager.GetCapabilities(state.Request.DeviceId);
if (caps != null)
{
state.DeviceProfile = caps.DeviceProfile;
}
else
{
state.DeviceProfile = DlnaManager.GetProfile(headers);
}
}
}
2014-05-18 21:23:03 +00:00
2014-04-23 02:47:46 +00:00
var profile = state.DeviceProfile;
2014-03-26 15:17:36 +00:00
if (profile == null)
{
// Don't use settings from the default profile.
// Only use a specific profile if it was requested.
return;
}
2014-03-25 05:25:03 +00:00
2014-10-20 03:04:45 +00:00
var audioCodec = state.ActualOutputAudioCodec;
var videoCodec = state.ActualOutputVideoCodec;
2014-03-25 05:25:03 +00:00
var mediaProfile = state.VideoRequest == null ?
2014-04-24 05:08:10 +00:00
profile.GetAudioMediaProfile(state.OutputContainer, audioCodec, state.OutputAudioChannels, state.OutputAudioBitrate) :
profile.GetVideoMediaProfile(state.OutputContainer,
audioCodec,
2014-04-24 05:08:10 +00:00
videoCodec,
state.OutputWidth,
state.OutputHeight,
state.TargetVideoBitDepth,
state.OutputVideoBitrate,
state.TargetVideoProfile,
state.TargetVideoLevel,
state.TargetFramerate,
state.TargetPacketLength,
2014-06-22 16:25:47 +00:00
state.TargetTimestamp,
2014-09-09 01:15:31 +00:00
state.IsTargetAnamorphic,
2014-10-23 04:26:01 +00:00
state.IsTargetCabac,
state.TargetRefFrames,
state.TargetVideoStreamCount,
2015-10-19 16:05:03 +00:00
state.TargetAudioStreamCount,
state.TargetVideoCodecTag);
2014-03-25 05:25:03 +00:00
if (mediaProfile != null)
{
state.MimeType = mediaProfile.MimeType;
}
2015-06-03 03:15:46 +00:00
if (!state.Request.Static)
2014-03-25 05:25:03 +00:00
{
2015-06-03 03:15:46 +00:00
var transcodingProfile = state.VideoRequest == null ?
profile.GetAudioTranscodingProfile(state.OutputContainer, audioCodec) :
profile.GetVideoTranscodingProfile(state.OutputContainer, audioCodec, videoCodec);
if (transcodingProfile != null)
{
state.EstimateContentLength = transcodingProfile.EstimateContentLength;
state.EnableMpegtsM2TsMode = transcodingProfile.EnableMpegtsM2TsMode;
state.TranscodeSeekInfo = transcodingProfile.TranscodeSeekInfo;
}
2014-03-25 05:25:03 +00:00
}
}
/// <summary>
/// Adds the dlna headers.
/// </summary>
/// <param name="state">The state.</param>
/// <param name="responseHeaders">The response headers.</param>
/// <param name="isStaticallyStreamed">if set to <c>true</c> [is statically streamed].</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise</returns>
protected void AddDlnaHeaders(StreamState state, IDictionary<string, string> responseHeaders, bool isStaticallyStreamed)
{
2014-04-23 02:47:46 +00:00
var profile = state.DeviceProfile;
2014-03-25 05:25:03 +00:00
var transferMode = GetHeader("transferMode.dlna.org");
responseHeaders["transferMode.dlna.org"] = string.IsNullOrEmpty(transferMode) ? "Streaming" : transferMode;
responseHeaders["realTimeInfo.dlna.org"] = "DLNA.ORG_TLAG=*";
2015-06-02 01:26:51 +00:00
if (string.Equals(GetHeader("getMediaInfo.sec"), "1", StringComparison.OrdinalIgnoreCase))
{
if (state.RunTimeTicks.HasValue)
{
var ms = TimeSpan.FromTicks(state.RunTimeTicks.Value).TotalMilliseconds;
responseHeaders["MediaInfo.sec"] = string.Format("SEC_Duration={0};", Convert.ToInt32(ms).ToString(CultureInfo.InvariantCulture));
}
}
2014-05-03 20:43:22 +00:00
if (state.RunTimeTicks.HasValue && !isStaticallyStreamed && profile != null)
2014-04-01 22:23:07 +00:00
{
2014-04-18 05:03:01 +00:00
AddTimeSeekResponseHeaders(state, responseHeaders);
2014-04-01 22:23:07 +00:00
}
2014-03-25 05:25:03 +00:00
2014-05-03 20:50:28 +00:00
if (profile == null)
{
profile = DlnaManager.GetDefaultProfile();
}
2014-10-20 03:04:45 +00:00
var audioCodec = state.ActualOutputAudioCodec;
if (state.VideoRequest == null)
2014-03-25 05:25:03 +00:00
{
2014-04-23 02:47:46 +00:00
responseHeaders["contentFeatures.dlna.org"] = new ContentFeatureBuilder(profile)
.BuildAudioHeader(
state.OutputContainer,
audioCodec,
state.OutputAudioBitrate,
state.OutputAudioSampleRate,
2014-04-23 02:47:46 +00:00
state.OutputAudioChannels,
isStaticallyStreamed,
state.RunTimeTicks,
state.TranscodeSeekInfo
);
2014-03-25 05:25:03 +00:00
}
2014-04-23 02:47:46 +00:00
else
2014-03-25 05:25:03 +00:00
{
2014-10-20 03:04:45 +00:00
var videoCodec = state.ActualOutputVideoCodec;
2014-04-23 02:47:46 +00:00
responseHeaders["contentFeatures.dlna.org"] = new ContentFeatureBuilder(profile)
.BuildVideoHeader(
state.OutputContainer,
videoCodec,
audioCodec,
state.OutputWidth,
state.OutputHeight,
2014-04-24 05:08:10 +00:00
state.TargetVideoBitDepth,
state.OutputVideoBitrate,
state.TargetTimestamp,
2014-04-23 02:47:46 +00:00
isStaticallyStreamed,
state.RunTimeTicks,
2014-04-24 05:08:10 +00:00
state.TargetVideoProfile,
state.TargetVideoLevel,
state.TargetFramerate,
state.TargetPacketLength,
2014-06-22 16:25:47 +00:00
state.TranscodeSeekInfo,
2014-09-09 01:15:31 +00:00
state.IsTargetAnamorphic,
2014-10-23 04:26:01 +00:00
state.IsTargetCabac,
state.TargetRefFrames,
state.TargetVideoStreamCount,
2015-10-19 16:05:03 +00:00
state.TargetAudioStreamCount,
state.TargetVideoCodecTag
2014-07-31 02:09:23 +00:00
).FirstOrDefault() ?? string.Empty;
2014-04-23 02:47:46 +00:00
}
2014-04-23 02:47:46 +00:00
foreach (var item in responseHeaders)
{
Request.Response.AddHeader(item.Key, item.Value);
}
2014-03-25 05:25:03 +00:00
}
2014-04-01 22:23:07 +00:00
private void AddTimeSeekResponseHeaders(StreamState state, IDictionary<string, string> responseHeaders)
{
var runtimeSeconds = TimeSpan.FromTicks(state.RunTimeTicks.Value).TotalSeconds.ToString(UsCulture);
var startSeconds = TimeSpan.FromTicks(state.Request.StartTimeTicks ?? 0).TotalSeconds.ToString(UsCulture);
responseHeaders["TimeSeekRange.dlna.org"] = string.Format("npt={0}-{1}/{1}", startSeconds, runtimeSeconds);
responseHeaders["X-AvailableSeekRange"] = string.Format("1 npt={0}-{1}", startSeconds, runtimeSeconds);
}
/// <summary>
/// Enforces the resolution limit.
/// </summary>
/// <param name="state">The state.</param>
/// <param name="videoRequest">The video request.</param>
private void EnforceResolutionLimit(StreamState state, VideoStreamRequest videoRequest)
{
2014-02-03 02:11:25 +00:00
// Switch the incoming params to be ceilings rather than fixed values
videoRequest.MaxWidth = videoRequest.MaxWidth ?? videoRequest.Width;
videoRequest.MaxHeight = videoRequest.MaxHeight ?? videoRequest.Height;
videoRequest.Width = null;
videoRequest.Height = null;
}
2014-06-28 19:35:30 +00:00
protected string GetInputModifier(StreamState state, bool genPts = true)
2014-01-22 01:37:01 +00:00
{
var inputModifier = string.Empty;
var probeSize = GetProbeSizeArgument(state);
inputModifier += " " + probeSize;
inputModifier = inputModifier.Trim();
2014-02-02 14:47:00 +00:00
var userAgentParam = GetUserAgentParam(state);
2014-06-04 19:40:05 +00:00
if (!string.IsNullOrWhiteSpace(userAgentParam))
{
inputModifier += " " + userAgentParam;
2014-06-02 19:32:41 +00:00
}
inputModifier = inputModifier.Trim();
inputModifier += " " + GetFastSeekCommandLineParameter(state.Request);
inputModifier = inputModifier.Trim();
2014-06-28 19:35:30 +00:00
if (state.VideoRequest != null && genPts)
{
2014-06-28 19:35:30 +00:00
inputModifier += " -fflags +genpts";
}
2014-03-21 04:52:28 +00:00
if (!string.IsNullOrEmpty(state.InputAudioSync))
{
inputModifier += " -async " + state.InputAudioSync;
}
if (!string.IsNullOrEmpty(state.InputVideoSync))
{
inputModifier += " -vsync " + state.InputVideoSync;
}
2014-01-22 01:37:01 +00:00
if (state.ReadInputAtNativeFramerate)
{
inputModifier += " -re";
}
2015-09-20 02:06:56 +00:00
var videoDecoder = GetVideoDecoder(state);
if (!string.IsNullOrWhiteSpace(videoDecoder))
{
inputModifier += " " + videoDecoder;
}
2014-01-22 01:37:01 +00:00
return inputModifier;
}
2013-02-27 04:44:41 +00:00
/// <summary>
/// Infers the audio codec based on the url
/// </summary>
/// <param name="url">The URL.</param>
/// <returns>System.Nullable{AudioCodecs}.</returns>
2014-03-23 20:07:02 +00:00
private string InferAudioCodec(string url)
2013-02-27 04:44:41 +00:00
{
var ext = Path.GetExtension(url);
if (string.Equals(ext, ".mp3", StringComparison.OrdinalIgnoreCase))
{
2014-03-23 20:07:02 +00:00
return "mp3";
2013-02-27 04:44:41 +00:00
}
if (string.Equals(ext, ".aac", StringComparison.OrdinalIgnoreCase))
{
2014-03-23 20:07:02 +00:00
return "aac";
2013-02-27 04:44:41 +00:00
}
2013-03-09 15:24:38 +00:00
if (string.Equals(ext, ".wma", StringComparison.OrdinalIgnoreCase))
2013-02-27 04:44:41 +00:00
{
2014-03-23 20:07:02 +00:00
return "wma";
2013-02-27 04:44:41 +00:00
}
2013-03-09 15:24:38 +00:00
if (string.Equals(ext, ".ogg", StringComparison.OrdinalIgnoreCase))
{
2014-03-23 20:07:02 +00:00
return "vorbis";
2013-03-09 15:24:38 +00:00
}
if (string.Equals(ext, ".oga", StringComparison.OrdinalIgnoreCase))
{
2014-03-23 20:07:02 +00:00
return "vorbis";
2013-03-09 15:24:38 +00:00
}
if (string.Equals(ext, ".ogv", StringComparison.OrdinalIgnoreCase))
{
2014-03-23 20:07:02 +00:00
return "vorbis";
2013-03-09 15:24:38 +00:00
}
if (string.Equals(ext, ".webm", StringComparison.OrdinalIgnoreCase))
{
2014-03-23 20:07:02 +00:00
return "vorbis";
2013-03-09 15:24:38 +00:00
}
if (string.Equals(ext, ".webma", StringComparison.OrdinalIgnoreCase))
{
2014-03-23 20:07:02 +00:00
return "vorbis";
2013-03-09 15:24:38 +00:00
}
2013-02-27 04:44:41 +00:00
2014-03-25 05:25:03 +00:00
return "copy";
2013-02-27 04:44:41 +00:00
}
/// <summary>
/// Infers the video codec.
/// </summary>
/// <param name="url">The URL.</param>
/// <returns>System.Nullable{VideoCodecs}.</returns>
2014-03-23 20:07:02 +00:00
private string InferVideoCodec(string url)
2013-02-27 04:44:41 +00:00
{
var ext = Path.GetExtension(url);
if (string.Equals(ext, ".asf", StringComparison.OrdinalIgnoreCase))
{
2014-03-23 20:07:02 +00:00
return "wmv";
2013-02-27 04:44:41 +00:00
}
if (string.Equals(ext, ".webm", StringComparison.OrdinalIgnoreCase))
{
2014-03-23 20:07:02 +00:00
return "vpx";
2013-02-27 04:44:41 +00:00
}
2013-03-09 15:24:38 +00:00
if (string.Equals(ext, ".ogg", StringComparison.OrdinalIgnoreCase) || string.Equals(ext, ".ogv", StringComparison.OrdinalIgnoreCase))
2013-02-27 04:44:41 +00:00
{
2014-03-23 20:07:02 +00:00
return "theora";
2013-02-27 04:44:41 +00:00
}
2013-03-09 15:24:38 +00:00
if (string.Equals(ext, ".m3u8", StringComparison.OrdinalIgnoreCase) || string.Equals(ext, ".ts", StringComparison.OrdinalIgnoreCase))
{
2014-03-23 20:07:02 +00:00
return "h264";
2013-03-09 15:24:38 +00:00
}
2013-02-27 04:44:41 +00:00
2014-03-23 20:07:02 +00:00
return "copy";
2013-02-27 04:44:41 +00:00
}
2013-02-27 04:19:05 +00:00
}
}