Cutlery/jellyfin
1
0
Fork 0
mirror of https://github.com/jellyfin/jellyfin.git synced 2025-11-04 03:27:21 -05:00
Code Issues Packages Projects Releases Wiki Activity

changes per suggestions

Browse Source
This commit is contained in:
nyanmisaka 2020-11-19 22:46:02 +08:00
parent 099563cd6b
commit 51dab0958d
4 changed files with 193 additions and 235 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

91
Jellyfin.Api/Controllers/DynamicHlsController.cs
View File

@ -43,7 +43,7 @@ namespace Jellyfin.Api.Controllers
public class DynamicHlsController : BaseJellyfinApiController public class DynamicHlsController : BaseJellyfinApiController
{ {
private const string DefaultEncoderPreset = "veryfast"; private const string DefaultEncoderPreset = "veryfast";
private readonly TranscodingJobType _transcodingJobType = TranscodingJobType.Hls; private const TranscodingJobType _transcodingJobType = TranscodingJobType.Hls;
private readonly ILibraryManager _libraryManager; private readonly ILibraryManager _libraryManager;
private readonly IUserManager _userManager; private readonly IUserManager _userManager;
@ -1446,58 +1446,38 @@ namespace Jellyfin.Api.Controllers
{ {
if (EncodingHelper.IsCopyCodec(audioCodec)) if (EncodingHelper.IsCopyCodec(audioCodec))
{ {
var segmentFormat = HlsHelpers.GetSegmentFileExtension(state.Request.SegmentContainer).TrimStart('.'); var bitStreamArgs = EncodingHelper.GetAudioBitStreamArguments(state, state.Request.SegmentContainer, state.MediaSource.Container);
var bitStreamArgs = string.Empty;
// Apply aac_adtstoasc bitstream filter when media source is in mpegts.
if (string.Equals(segmentFormat, "mp4", StringComparison.OrdinalIgnoreCase)
&& (string.Equals(state.MediaSource.Container, "mpegts", StringComparison.OrdinalIgnoreCase)
|| string.Equals(state.MediaSource.Container, "hls", StringComparison.OrdinalIgnoreCase)))
{
bitStreamArgs = _encodingHelper.GetBitStreamArgs(state.AudioStream);
bitStreamArgs = string.IsNullOrEmpty(bitStreamArgs) ? string.Empty : " " + bitStreamArgs;
}
return "-acodec copy -strict -2" + bitStreamArgs; return "-acodec copy -strict -2" + bitStreamArgs;
} }
var audioTranscodeParams = new List<string>(); var audioTranscodeParams = string.Empty;
audioTranscodeParams.Add("-acodec " + audioCodec); audioTranscodeParams += "-acodec " + audioCodec;
if (state.OutputAudioBitrate.HasValue) if (state.OutputAudioBitrate.HasValue)
{ {
audioTranscodeParams.Add("-ab " + state.OutputAudioBitrate.Value.ToString(CultureInfo.InvariantCulture)); audioTranscodeParams += " -ab " + state.OutputAudioBitrate.Value.ToString(CultureInfo.InvariantCulture);
} }
if (state.OutputAudioChannels.HasValue) if (state.OutputAudioChannels.HasValue)
{ {
audioTranscodeParams.Add("-ac " + state.OutputAudioChannels.Value.ToString(CultureInfo.InvariantCulture)); audioTranscodeParams += " -ac " + state.OutputAudioChannels.Value.ToString(CultureInfo.InvariantCulture);
} }
if (state.OutputAudioSampleRate.HasValue) if (state.OutputAudioSampleRate.HasValue)
{ {
audioTranscodeParams.Add("-ar " + state.OutputAudioSampleRate.Value.ToString(CultureInfo.InvariantCulture)); audioTranscodeParams += " -ar " + state.OutputAudioSampleRate.Value.ToString(CultureInfo.InvariantCulture);
} }
audioTranscodeParams.Add("-vn"); audioTranscodeParams += " -vn";
return string.Join(' ', audioTranscodeParams); return audioTranscodeParams;
} }
if (EncodingHelper.IsCopyCodec(audioCodec)) if (EncodingHelper.IsCopyCodec(audioCodec))
{ {
var videoCodec = _encodingHelper.GetVideoEncoder(state, _encodingOptions); var videoCodec = _encodingHelper.GetVideoEncoder(state, _encodingOptions);
var segmentFormat = HlsHelpers.GetSegmentFileExtension(state.Request.SegmentContainer).TrimStart('.'); var bitStreamArgs = EncodingHelper.GetAudioBitStreamArguments(state, state.Request.SegmentContainer, state.MediaSource.Container);
var bitStreamArgs = string.Empty;
// Apply aac_adtstoasc bitstream filter when media source is in mpegts.
if (string.Equals(segmentFormat, "mp4", StringComparison.OrdinalIgnoreCase)
&& (string.Equals(state.MediaSource.Container, "mpegts", StringComparison.OrdinalIgnoreCase)
|| string.Equals(state.MediaSource.Container, "hls", StringComparison.OrdinalIgnoreCase)))
{
bitStreamArgs = _encodingHelper.GetBitStreamArgs(state.AudioStream);
bitStreamArgs = string.IsNullOrEmpty(bitStreamArgs) ? string.Empty : " " + bitStreamArgs;
}
if (EncodingHelper.IsCopyCodec(videoCodec) && state.EnableBreakOnNonKeyFrames(videoCodec)) if (EncodingHelper.IsCopyCodec(videoCodec) && state.EnableBreakOnNonKeyFrames(videoCodec))
{ {
@ -1528,7 +1508,7 @@ namespace Jellyfin.Api.Controllers
args += " -ar " + state.OutputAudioSampleRate.Value.ToString(CultureInfo.InvariantCulture); args += " -ar " + state.OutputAudioSampleRate.Value.ToString(CultureInfo.InvariantCulture);
} }
args += " " + _encodingHelper.GetAudioFilterParam(state, _encodingOptions, true); args += _encodingHelper.GetAudioFilterParam(state, _encodingOptions, true);
return args; return args;
} }
@ -1574,7 +1554,7 @@ namespace Jellyfin.Api.Controllers
{ {
if (state.VideoStream != null && !string.Equals(state.VideoStream.NalLengthSize, "0", StringComparison.OrdinalIgnoreCase)) if (state.VideoStream != null && !string.Equals(state.VideoStream.NalLengthSize, "0", StringComparison.OrdinalIgnoreCase))
{ {
string bitStreamArgs = _encodingHelper.GetBitStreamArgs(state.VideoStream); string bitStreamArgs = EncodingHelper.GetBitStreamArgs(state.VideoStream);
if (!string.IsNullOrEmpty(bitStreamArgs)) if (!string.IsNullOrEmpty(bitStreamArgs))
{ {
args += " " + bitStreamArgs; args += " " + bitStreamArgs;
@ -1587,51 +1567,10 @@ namespace Jellyfin.Api.Controllers
} }
else else
{ {
var gopArg = string.Empty; args += _encodingHelper.GetVideoQualityParam(state, codec, _encodingOptions, DefaultEncoderPreset);
var keyFrameArg = string.Format(
CultureInfo.InvariantCulture,
" -force_key_frames:0 \"expr:gte(t,{0}+n_forced*{1})\"",
startNumber * state.SegmentLength,
state.SegmentLength);
var framerate = state.VideoStream?.RealFrameRate; // Set the key frame params for video encoding to match the hls segment time.
if (framerate.HasValue) args += _encodingHelper.GetHlsVideoKeyFrameArguments(state, codec, state.SegmentLength, false, startNumber);
{
// This is to make sure keyframe interval is limited to our segment,
// as forcing keyframes is not enough.
// Example: we encoded half of desired length, then codec detected
// scene cut and inserted a keyframe; next forced keyframe would
// be created outside of segment, which breaks seeking.
// -sc_threshold 0 is used to prevent the hardware encoder from post processing to break the set keyframe.
gopArg = string.Format(
CultureInfo.InvariantCulture,
" -g {0} -keyint_min {0} -sc_threshold 0",
Math.Ceiling(state.SegmentLength * framerate.Value));
}
args += " " + _encodingHelper.GetVideoQualityParam(state, codec, _encodingOptions, DefaultEncoderPreset);
// Unable to force key frames using these encoders, set key frames by GOP.
if (string.Equals(codec, "h264_qsv", StringComparison.OrdinalIgnoreCase)
|| string.Equals(codec, "h264_nvenc", StringComparison.OrdinalIgnoreCase)
|| string.Equals(codec, "h264_amf", StringComparison.OrdinalIgnoreCase)
|| string.Equals(codec, "hevc_qsv", StringComparison.OrdinalIgnoreCase)
|| string.Equals(codec, "hevc_nvenc", StringComparison.OrdinalIgnoreCase)
|| string.Equals(codec, "hevc_amf", StringComparison.OrdinalIgnoreCase))
{
args += " " + gopArg;
}
else if (string.Equals(codec, "libx264", StringComparison.OrdinalIgnoreCase)
|| string.Equals(codec, "libx265", StringComparison.OrdinalIgnoreCase)
|| string.Equals(codec, "h264_vaapi", StringComparison.OrdinalIgnoreCase)
|| string.Equals(codec, "hevc_vaapi", StringComparison.OrdinalIgnoreCase))
{
args += " " + keyFrameArg;
}
else
{
args += " " + keyFrameArg + gopArg;
}
// Currenly b-frames in libx265 breaks the FMP4-HLS playback on iOS, disable it for now. // Currenly b-frames in libx265 breaks the FMP4-HLS playback on iOS, disable it for now.
if (string.Equals(codec, "libx265", StringComparison.OrdinalIgnoreCase)) if (string.Equals(codec, "libx265", StringComparison.OrdinalIgnoreCase))

90
Jellyfin.Api/Controllers/VideoHlsController.cs
View File

@ -367,7 +367,7 @@ namespace Jellyfin.Api.Controllers
var directory = Path.GetDirectoryName(outputPath) ?? throw new ArgumentException($"Provided path ({outputPath}) is not valid.", nameof(outputPath)); var directory = Path.GetDirectoryName(outputPath) ?? throw new ArgumentException($"Provided path ({outputPath}) is not valid.", nameof(outputPath));
var outputFileNameWithoutExtension = Path.GetFileNameWithoutExtension(outputPath); var outputFileNameWithoutExtension = Path.GetFileNameWithoutExtension(outputPath);
var outputPrefix = Path.Combine(directory, outputFileNameWithoutExtension); var outputPrefix = Path.Combine(directory, outputFileNameWithoutExtension);
var outputExtension = HlsHelpers.GetSegmentFileExtension(state.Request.SegmentContainer); var outputExtension = EncodingHelper.GetSegmentFileExtension(state.Request.SegmentContainer);
var outputTsArg = outputPrefix + "%d" + outputExtension; var outputTsArg = outputPrefix + "%d" + outputExtension;
var segmentFormat = outputExtension.TrimStart('.'); var segmentFormat = outputExtension.TrimStart('.');
@ -441,57 +441,37 @@ namespace Jellyfin.Api.Controllers
{ {
if (EncodingHelper.IsCopyCodec(audioCodec)) if (EncodingHelper.IsCopyCodec(audioCodec))
{ {
var segmentFormat = HlsHelpers.GetSegmentFileExtension(state.Request.SegmentContainer).TrimStart('.'); var bitStreamArgs = EncodingHelper.GetAudioBitStreamArguments(state, state.Request.SegmentContainer, state.MediaSource.Container);
var bitStreamArgs = string.Empty;
// Apply aac_adtstoasc bitstream filter when media source is in mpegts.
if (string.Equals(segmentFormat, "mp4", StringComparison.OrdinalIgnoreCase)
&& (string.Equals(state.MediaSource.Container, "mpegts", StringComparison.OrdinalIgnoreCase)
|| string.Equals(state.MediaSource.Container, "hls", StringComparison.OrdinalIgnoreCase)))
{
bitStreamArgs = _encodingHelper.GetBitStreamArgs(state.AudioStream);
bitStreamArgs = string.IsNullOrEmpty(bitStreamArgs) ? string.Empty : " " + bitStreamArgs;
}
return "-acodec copy -strict -2" + bitStreamArgs; return "-acodec copy -strict -2" + bitStreamArgs;
} }
var audioTranscodeParams = new List<string>(); var audioTranscodeParams = string.Empty;
audioTranscodeParams.Add("-acodec " + audioCodec); audioTranscodeParams += "-acodec " + audioCodec;
if (state.OutputAudioBitrate.HasValue) if (state.OutputAudioBitrate.HasValue)
{ {
audioTranscodeParams.Add("-ab " + state.OutputAudioBitrate.Value.ToString(CultureInfo.InvariantCulture)); audioTranscodeParams += " -ab " + state.OutputAudioBitrate.Value.ToString(CultureInfo.InvariantCulture);
} }
if (state.OutputAudioChannels.HasValue) if (state.OutputAudioChannels.HasValue)
{ {
audioTranscodeParams.Add("-ac " + state.OutputAudioChannels.Value.ToString(CultureInfo.InvariantCulture)); audioTranscodeParams += " -ac " + state.OutputAudioChannels.Value.ToString(CultureInfo.InvariantCulture);
} }
if (state.OutputAudioSampleRate.HasValue) if (state.OutputAudioSampleRate.HasValue)
{ {
audioTranscodeParams.Add("-ar " + state.OutputAudioSampleRate.Value.ToString(CultureInfo.InvariantCulture)); audioTranscodeParams += " -ar " + state.OutputAudioSampleRate.Value.ToString(CultureInfo.InvariantCulture);
} }
audioTranscodeParams.Add("-vn"); audioTranscodeParams += " -vn";
return string.Join(' ', audioTranscodeParams); return audioTranscodeParams;
} }
if (EncodingHelper.IsCopyCodec(audioCodec)) if (EncodingHelper.IsCopyCodec(audioCodec))
{ {
var segmentFormat = HlsHelpers.GetSegmentFileExtension(state.Request.SegmentContainer).TrimStart('.'); var bitStreamArgs = EncodingHelper.GetAudioBitStreamArguments(state, state.Request.SegmentContainer, state.MediaSource.Container);
var bitStreamArgs = string.Empty;
// Apply aac_adtstoasc bitstream filter when media source is in mpegts.
if (string.Equals(segmentFormat, "mp4", StringComparison.OrdinalIgnoreCase)
&& (string.Equals(state.MediaSource.Container, "mpegts", StringComparison.OrdinalIgnoreCase)
|| string.Equals(state.MediaSource.Container, "hls", StringComparison.OrdinalIgnoreCase)))
{
bitStreamArgs = _encodingHelper.GetBitStreamArgs(state.AudioStream);
bitStreamArgs = !string.IsNullOrEmpty(bitStreamArgs) ? " " + bitStreamArgs : string.Empty;
}
return "-acodec copy -strict -2" + bitStreamArgs; return "-acodec copy -strict -2" + bitStreamArgs;
} }
@ -517,7 +497,7 @@ namespace Jellyfin.Api.Controllers
args += " -ar " + state.OutputAudioSampleRate.Value.ToString(CultureInfo.InvariantCulture); args += " -ar " + state.OutputAudioSampleRate.Value.ToString(CultureInfo.InvariantCulture);
} }
args += " " + _encodingHelper.GetAudioFilterParam(state, _encodingOptions, true); args += _encodingHelper.GetAudioFilterParam(state, _encodingOptions, true);
return args; return args;
} }
@ -563,7 +543,7 @@ namespace Jellyfin.Api.Controllers
// If h264_mp4toannexb is ever added, do not use it for live tv. // If h264_mp4toannexb is ever added, do not use it for live tv.
if (state.VideoStream != null && !string.Equals(state.VideoStream.NalLengthSize, "0", StringComparison.OrdinalIgnoreCase)) if (state.VideoStream != null && !string.Equals(state.VideoStream.NalLengthSize, "0", StringComparison.OrdinalIgnoreCase))
{ {
string bitStreamArgs = _encodingHelper.GetBitStreamArgs(state.VideoStream); string bitStreamArgs = EncodingHelper.GetBitStreamArgs(state.VideoStream);
if (!string.IsNullOrEmpty(bitStreamArgs)) if (!string.IsNullOrEmpty(bitStreamArgs))
{ {
args += " " + bitStreamArgs; args += " " + bitStreamArgs;
@ -574,50 +554,10 @@ namespace Jellyfin.Api.Controllers
} }
else else
{ {
var gopArg = string.Empty; args += _encodingHelper.GetVideoQualityParam(state, codec, _encodingOptions, DefaultEncoderPreset);
var keyFrameArg = string.Format(
CultureInfo.InvariantCulture,
" -force_key_frames \"expr:gte(t,n_forced*{0})\"",
state.SegmentLength.ToString(CultureInfo.InvariantCulture));
var framerate = state.VideoStream?.RealFrameRate; // Set the key frame params for video encoding to match the hls segment time.
if (framerate.HasValue) args += _encodingHelper.GetHlsVideoKeyFrameArguments(state, codec, state.SegmentLength, true, null);
{
// This is to make sure keyframe interval is limited to our segment,
// as forcing keyframes is not enough.
// Example: we encoded half of desired length, then codec detected
// scene cut and inserted a keyframe; next forced keyframe would
// be created outside of segment, which breaks seeking.
// -sc_threshold 0 is used to prevent the hardware encoder from post processing to break the set keyframe.
gopArg = string.Format(
CultureInfo.InvariantCulture,
" -g {0} -keyint_min {0} -sc_threshold 0",
Math.Ceiling(state.SegmentLength * framerate.Value));
}
args += " " + _encodingHelper.GetVideoQualityParam(state, codec, _encodingOptions, DefaultEncoderPreset);
// Unable to force key frames using these encoders, set key frames by GOP.
if (string.Equals(codec, "h264_qsv", StringComparison.OrdinalIgnoreCase)
|| string.Equals(codec, "h264_nvenc", StringComparison.OrdinalIgnoreCase)
|| string.Equals(codec, "h264_amf", StringComparison.OrdinalIgnoreCase)
|| string.Equals(codec, "hevc_qsv", StringComparison.OrdinalIgnoreCase)
|| string.Equals(codec, "hevc_nvenc", StringComparison.OrdinalIgnoreCase)
|| string.Equals(codec, "hevc_amf", StringComparison.OrdinalIgnoreCase))
{
args += " " + gopArg;
}
else if (string.Equals(codec, "libx264", StringComparison.OrdinalIgnoreCase)
|| string.Equals(codec, "libx265", StringComparison.OrdinalIgnoreCase)
|| string.Equals(codec, "h264_vaapi", StringComparison.OrdinalIgnoreCase)
|| string.Equals(codec, "hevc_vaapi", StringComparison.OrdinalIgnoreCase))
{
args += " " + keyFrameArg;
}
else
{
args += " " + keyFrameArg + gopArg;
}
// Currenly b-frames in libx265 breaks the FMP4-HLS playback on iOS, disable it for now. // Currenly b-frames in libx265 breaks the FMP4-HLS playback on iOS, disable it for now.
if (string.Equals(codec, "libx265", StringComparison.OrdinalIgnoreCase)) if (string.Equals(codec, "libx265", StringComparison.OrdinalIgnoreCase))

20
Jellyfin.Api/Helpers/HlsHelpers.cs
View File

@ -5,6 +5,7 @@ using System.Runtime.InteropServices;
using System.Threading; using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
using Jellyfin.Api.Models.StreamingDtos; using Jellyfin.Api.Models.StreamingDtos;
using MediaBrowser.Controller.MediaEncoding;
using MediaBrowser.Model.IO; using MediaBrowser.Model.IO;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
@ -76,21 +77,6 @@ namespace Jellyfin.Api.Helpers
} }
} }
/// <summary>
/// Gets the extension of segment container.
/// </summary>
/// <param name="segmentContainer">The name of the segment container.</param>
/// <returns>The string text of extension.</returns>
public static string GetSegmentFileExtension(string? segmentContainer)
{
if (!string.IsNullOrWhiteSpace(segmentContainer))
{
return "." + segmentContainer;
}
return ".ts";
}
/// <summary> /// <summary>
/// Gets the #EXT-X-MAP string. /// Gets the #EXT-X-MAP string.
/// </summary> /// </summary>
@ -103,7 +89,7 @@ namespace Jellyfin.Api.Helpers
var directory = Path.GetDirectoryName(outputPath) ?? throw new ArgumentException($"Provided path ({outputPath}) is not valid.", nameof(outputPath)); var directory = Path.GetDirectoryName(outputPath) ?? throw new ArgumentException($"Provided path ({outputPath}) is not valid.", nameof(outputPath));
var outputFileNameWithoutExtension = Path.GetFileNameWithoutExtension(outputPath); var outputFileNameWithoutExtension = Path.GetFileNameWithoutExtension(outputPath);
var outputPrefix = Path.Combine(directory, outputFileNameWithoutExtension); var outputPrefix = Path.Combine(directory, outputFileNameWithoutExtension);
var outputExtension = GetSegmentFileExtension(state.Request.SegmentContainer); var outputExtension = EncodingHelper.GetSegmentFileExtension(state.Request.SegmentContainer);
// on Linux/Unix // on Linux/Unix
// #EXT-X-MAP:URI="prefix-1.mp4" // #EXT-X-MAP:URI="prefix-1.mp4"
@ -137,7 +123,7 @@ namespace Jellyfin.Api.Helpers
var text = reader.ReadToEnd(); var text = reader.ReadToEnd();
var segmentFormat = GetSegmentFileExtension(state.Request.SegmentContainer).TrimStart('.'); var segmentFormat = EncodingHelper.GetSegmentFileExtension(state.Request.SegmentContainer).TrimStart('.');
if (string.Equals(segmentFormat, "mp4", StringComparison.OrdinalIgnoreCase)) if (string.Equals(segmentFormat, "mp4", StringComparison.OrdinalIgnoreCase))
{ {
var fmp4InitFileName = GetFmp4InitFileName(path, state, true); var fmp4InitFileName = GetFmp4InitFileName(path, state, true);

227
MediaBrowser.Controller/MediaEncoding/EncodingHelper.cs
View File

@ -580,7 +580,7 @@ namespace MediaBrowser.Controller.MediaEncoding
/// </summary> /// </summary>
/// <param name="stream">The stream.</param> /// <param name="stream">The stream.</param>
/// <returns><c>true</c> if the specified stream is H264; otherwise, <c>false</c>.</returns> /// <returns><c>true</c> if the specified stream is H264; otherwise, <c>false</c>.</returns>
public bool IsH264(MediaStream stream) public static bool IsH264(MediaStream stream)
{ {
var codec = stream.Codec ?? string.Empty; var codec = stream.Codec ?? string.Empty;
@ -588,7 +588,7 @@ namespace MediaBrowser.Controller.MediaEncoding
|| codec.IndexOf("avc", StringComparison.OrdinalIgnoreCase) != -1; || codec.IndexOf("avc", StringComparison.OrdinalIgnoreCase) != -1;
} }
public bool IsH265(MediaStream stream) public static bool IsH265(MediaStream stream)
{ {
var codec = stream.Codec ?? string.Empty; var codec = stream.Codec ?? string.Empty;
@ -596,14 +596,14 @@ namespace MediaBrowser.Controller.MediaEncoding
|| codec.IndexOf("hevc", StringComparison.OrdinalIgnoreCase) != -1; || codec.IndexOf("hevc", StringComparison.OrdinalIgnoreCase) != -1;
} }
public bool IsAAC(MediaStream stream) public static bool IsAAC(MediaStream stream)
{ {
var codec = stream.Codec ?? string.Empty; var codec = stream.Codec ?? string.Empty;
return codec.IndexOf("aac", StringComparison.OrdinalIgnoreCase) != -1; return codec.IndexOf("aac", StringComparison.OrdinalIgnoreCase) != -1;
} }
public string GetBitStreamArgs(MediaStream stream) public static string GetBitStreamArgs(MediaStream stream)
{ {
// TODO This is auto inserted into the mpegts mux so it might not be needed. // TODO This is auto inserted into the mpegts mux so it might not be needed.
// https://www.ffmpeg.org/ffmpeg-bitstream-filters.html#h264_005fmp4toannexb // https://www.ffmpeg.org/ffmpeg-bitstream-filters.html#h264_005fmp4toannexb
@ -626,6 +626,33 @@ namespace MediaBrowser.Controller.MediaEncoding
} }
} }
public static string GetAudioBitStreamArguments(EncodingJobInfo state, string segmentContainer, string mediaSourceContainer)
{
var bitStreamArgs = string.Empty;
var segmentFormat = GetSegmentFileExtension(segmentContainer).TrimStart('.');
// Apply aac_adtstoasc bitstream filter when media source is in mpegts.
if (string.Equals(segmentFormat, "mp4", StringComparison.OrdinalIgnoreCase)
&& (string.Equals(mediaSourceContainer, "mpegts", StringComparison.OrdinalIgnoreCase)
|| string.Equals(mediaSourceContainer, "hls", StringComparison.OrdinalIgnoreCase)))
{
bitStreamArgs = GetBitStreamArgs(state.AudioStream);
bitStreamArgs = string.IsNullOrEmpty(bitStreamArgs) ? string.Empty : " " + bitStreamArgs;
}
return bitStreamArgs;
}
public static string GetSegmentFileExtension(string segmentContainer)
{
if (!string.IsNullOrWhiteSpace(segmentContainer))
{
return "." + segmentContainer;
}
return ".ts";
}
public string GetVideoBitrateParam(EncodingJobInfo state, string videoCodec) public string GetVideoBitrateParam(EncodingJobInfo state, string videoCodec)
{ {
var bitrate = state.OutputVideoBitrate; var bitrate = state.OutputVideoBitrate;
@ -799,6 +826,72 @@ namespace MediaBrowser.Controller.MediaEncoding
return null; return null;
} }
public string GetHlsVideoKeyFrameArguments(
EncodingJobInfo state,
string codec,
int segmentLength,
bool isEventPlaylist,
int? startNumber)
{
var args = string.Empty;
var gopArg = string.Empty;
var keyFrameArg = string.Empty;
if (isEventPlaylist)
{
keyFrameArg = string.Format(
CultureInfo.InvariantCulture,
" -force_key_frames:0 \"expr:gte(t,n_forced*{0})\"",
segmentLength);
}
else if (startNumber.HasValue)
{
keyFrameArg = string.Format(
CultureInfo.InvariantCulture,
" -force_key_frames:0 \"expr:gte(t,{0}+n_forced*{1})\"",
startNumber.Value * segmentLength,
segmentLength);
}
var framerate = state.VideoStream?.RealFrameRate;
if (framerate.HasValue)
{
// This is to make sure keyframe interval is limited to our segment,
// as forcing keyframes is not enough.
// Example: we encoded half of desired length, then codec detected
// scene cut and inserted a keyframe; next forced keyframe would
// be created outside of segment, which breaks seeking.
// -sc_threshold 0 is used to prevent the hardware encoder from post processing to break the set keyframe.
gopArg = string.Format(
CultureInfo.InvariantCulture,
" -g:v:0 {0} -keyint_min:v:0 {0} -sc_threshold:v:0 0",
Math.Ceiling(segmentLength * framerate.Value));
}
// Unable to force key frames using these encoders, set key frames by GOP.
if (string.Equals(codec, "h264_qsv", StringComparison.OrdinalIgnoreCase)
|| string.Equals(codec, "h264_nvenc", StringComparison.OrdinalIgnoreCase)
|| string.Equals(codec, "h264_amf", StringComparison.OrdinalIgnoreCase)
|| string.Equals(codec, "hevc_qsv", StringComparison.OrdinalIgnoreCase)
|| string.Equals(codec, "hevc_nvenc", StringComparison.OrdinalIgnoreCase)
|| string.Equals(codec, "hevc_amf", StringComparison.OrdinalIgnoreCase))
{
args += gopArg;
}
else if (string.Equals(codec, "libx264", StringComparison.OrdinalIgnoreCase)
|| string.Equals(codec, "libx265", StringComparison.OrdinalIgnoreCase)
|| string.Equals(codec, "h264_vaapi", StringComparison.OrdinalIgnoreCase)
|| string.Equals(codec, "hevc_vaapi", StringComparison.OrdinalIgnoreCase))
{
args += " " + keyFrameArg;
}
else
{
args += " " + keyFrameArg + gopArg;
}
return args;
}
/// <summary> /// <summary>
/// Gets the video bitrate to specify on the command line. /// Gets the video bitrate to specify on the command line.
/// </summary> /// </summary>
@ -806,6 +899,47 @@ namespace MediaBrowser.Controller.MediaEncoding
{ {
var param = string.Empty; var param = string.Empty;
if (!string.Equals(videoEncoder, "h264_omx", StringComparison.OrdinalIgnoreCase)
&& !string.Equals(videoEncoder, "h264_qsv", StringComparison.OrdinalIgnoreCase)
&& !string.Equals(videoEncoder, "h264_vaapi", StringComparison.OrdinalIgnoreCase)
&& !string.Equals(videoEncoder, "h264_nvenc", StringComparison.OrdinalIgnoreCase)
&& !string.Equals(videoEncoder, "h264_amf", StringComparison.OrdinalIgnoreCase)
&& !string.Equals(videoEncoder, "h264_v4l2m2m", StringComparison.OrdinalIgnoreCase)
&& !string.Equals(videoEncoder, "hevc_qsv", StringComparison.OrdinalIgnoreCase)
&& !string.Equals(videoEncoder, "hevc_vaapi", StringComparison.OrdinalIgnoreCase)
&& !string.Equals(videoEncoder, "hevc_nvenc", StringComparison.OrdinalIgnoreCase)
&& !string.Equals(videoEncoder, "hevc_amf", StringComparison.OrdinalIgnoreCase))
{
param += " -pix_fmt yuv420p";
}
if (string.Equals(videoEncoder, "h264_nvenc", StringComparison.OrdinalIgnoreCase)
|| string.Equals(videoEncoder, "h264_amf", StringComparison.OrdinalIgnoreCase)
|| string.Equals(videoEncoder, "hevc_nvenc", StringComparison.OrdinalIgnoreCase)
|| string.Equals(videoEncoder, "hevc_amf", StringComparison.OrdinalIgnoreCase))
{
var videoStream = state.VideoStream;
var isColorDepth10 = IsColorDepth10(state);
if (isColorDepth10
&& _mediaEncoder.SupportsHwaccel("opencl")
&& encodingOptions.EnableTonemapping
&& !string.IsNullOrEmpty(videoStream.VideoRange)
&& videoStream.VideoRange.Contains("HDR", StringComparison.OrdinalIgnoreCase))
{
param += " -pix_fmt nv12";
}
else
{
param += " -pix_fmt yuv420p";
}
}
if (string.Equals(videoEncoder, "h264_v4l2m2m", StringComparison.OrdinalIgnoreCase))
{
param += " -pix_fmt nv21";
}
var isVc1 = state.VideoStream != null && var isVc1 = state.VideoStream != null &&
string.Equals(state.VideoStream.Codec, "vc1", StringComparison.OrdinalIgnoreCase); string.Equals(state.VideoStream.Codec, "vc1", StringComparison.OrdinalIgnoreCase);
var isLibX265 = string.Equals(videoEncoder, "libx265", StringComparison.OrdinalIgnoreCase); var isLibX265 = string.Equals(videoEncoder, "libx265", StringComparison.OrdinalIgnoreCase);
@ -814,11 +948,11 @@ namespace MediaBrowser.Controller.MediaEncoding
{ {
if (!string.IsNullOrEmpty(encodingOptions.EncoderPreset)) if (!string.IsNullOrEmpty(encodingOptions.EncoderPreset))
{ {
param += "-preset " + encodingOptions.EncoderPreset; param += " -preset " + encodingOptions.EncoderPreset;
} }
else else
{ {
param += "-preset " + defaultPreset; param += " -preset " + defaultPreset;
} }
int encodeCrf = encodingOptions.H264Crf; int encodeCrf = encodingOptions.H264Crf;
@ -849,11 +983,11 @@ namespace MediaBrowser.Controller.MediaEncoding
if (valid_h264_qsv.Contains(encodingOptions.EncoderPreset, StringComparer.OrdinalIgnoreCase)) if (valid_h264_qsv.Contains(encodingOptions.EncoderPreset, StringComparer.OrdinalIgnoreCase))
{ {
param += "-preset " + encodingOptions.EncoderPreset; param += " -preset " + encodingOptions.EncoderPreset;
} }
else else
{ {
param += "-preset 7"; param += " -preset 7";
} }
param += " -look_ahead 0"; param += " -look_ahead 0";
@ -866,16 +1000,16 @@ namespace MediaBrowser.Controller.MediaEncoding
{ {
case "veryslow": case "veryslow":
param += "-preset slow"; // lossless is only supported on maxwell and newer(2014+) param += " -preset slow"; // lossless is only supported on maxwell and newer(2014+)
break; break;
case "slow": case "slow":
case "slower": case "slower":
param += "-preset slow"; param += " -preset slow";
break; break;
case "medium": case "medium":
param += "-preset medium"; param += " -preset medium";
break; break;
case "fast": case "fast":
@ -883,11 +1017,11 @@ namespace MediaBrowser.Controller.MediaEncoding
case "veryfast": case "veryfast":
case "superfast": case "superfast":
case "ultrafast": case "ultrafast":
param += "-preset fast"; param += " -preset fast";
break; break;
default: default:
param += "-preset default"; param += " -preset default";
break; break;
} }
} }
@ -899,11 +1033,11 @@ namespace MediaBrowser.Controller.MediaEncoding
case "veryslow": case "veryslow":
case "slow": case "slow":
case "slower": case "slower":
param += "-quality quality"; param += " -quality quality";
break; break;
case "medium": case "medium":
param += "-quality balanced"; param += " -quality balanced";
break; break;
case "fast": case "fast":
@ -911,11 +1045,11 @@ namespace MediaBrowser.Controller.MediaEncoding
case "veryfast": case "veryfast":
case "superfast": case "superfast":
case "ultrafast": case "ultrafast":
param += "-quality speed"; param += " -quality speed";
break; break;
default: default:
param += "-quality speed"; param += " -quality speed";
break; break;
} }
@ -957,7 +1091,7 @@ namespace MediaBrowser.Controller.MediaEncoding
profileScore = Math.Min(profileScore, 2); profileScore = Math.Min(profileScore, 2);
// http://www.webmproject.org/docs/encoder-parameters/ // http://www.webmproject.org/docs/encoder-parameters/
param += string.Format(CultureInfo.InvariantCulture, "-speed 16 -quality good -profile:v {0} -slices 8 -crf {1} -qmin {2} -qmax {3}", param += string.Format(CultureInfo.InvariantCulture, " -speed 16 -quality good -profile:v {0} -slices 8 -crf {1} -qmin {2} -qmax {3}",
profileScore.ToString(_usCulture), profileScore.ToString(_usCulture),
crf, crf,
qmin, qmin,
@ -965,15 +1099,15 @@ namespace MediaBrowser.Controller.MediaEncoding
} }
else if (string.Equals(videoEncoder, "mpeg4", StringComparison.OrdinalIgnoreCase)) else if (string.Equals(videoEncoder, "mpeg4", StringComparison.OrdinalIgnoreCase))
{ {
param += "-mbd rd -flags +mv4+aic -trellis 2 -cmp 2 -subcmp 2 -bf 2"; param += " -mbd rd -flags +mv4+aic -trellis 2 -cmp 2 -subcmp 2 -bf 2";
} }
else if (string.Equals(videoEncoder, "wmv2", StringComparison.OrdinalIgnoreCase)) // asf/wmv else if (string.Equals(videoEncoder, "wmv2", StringComparison.OrdinalIgnoreCase)) // asf/wmv
{ {
param += "-qmin 2"; param += " -qmin 2";
} }
else if (string.Equals(videoEncoder, "msmpeg4", StringComparison.OrdinalIgnoreCase)) else if (string.Equals(videoEncoder, "msmpeg4", StringComparison.OrdinalIgnoreCase))
{ {
param += "-mbd 2"; param += " -mbd 2";
} }
param += GetVideoBitrateParam(state, videoEncoder); param += GetVideoBitrateParam(state, videoEncoder);
@ -1035,7 +1169,7 @@ namespace MediaBrowser.Controller.MediaEncoding
&& !string.Equals(videoEncoder, "h264_v4l2m2m", StringComparison.OrdinalIgnoreCase)) && !string.Equals(videoEncoder, "h264_v4l2m2m", StringComparison.OrdinalIgnoreCase))
{ {
// not supported by h264_omx // not supported by h264_omx
param += " -profile:v " + profile; param += " -profile:v:0 " + profile;
} }
} }
@ -1091,47 +1225,6 @@ namespace MediaBrowser.Controller.MediaEncoding
param += " -x265-params:0 no-info=1"; param += " -x265-params:0 no-info=1";
} }
if (!string.Equals(videoEncoder, "h264_omx", StringComparison.OrdinalIgnoreCase)
&& !string.Equals(videoEncoder, "h264_qsv", StringComparison.OrdinalIgnoreCase)
&& !string.Equals(videoEncoder, "h264_vaapi", StringComparison.OrdinalIgnoreCase)
&& !string.Equals(videoEncoder, "h264_nvenc", StringComparison.OrdinalIgnoreCase)
&& !string.Equals(videoEncoder, "h264_amf", StringComparison.OrdinalIgnoreCase)
&& !string.Equals(videoEncoder, "h264_v4l2m2m", StringComparison.OrdinalIgnoreCase)
&& !string.Equals(videoEncoder, "hevc_qsv", StringComparison.OrdinalIgnoreCase)
&& !string.Equals(videoEncoder, "hevc_vaapi", StringComparison.OrdinalIgnoreCase)
&& !string.Equals(videoEncoder, "hevc_nvenc", StringComparison.OrdinalIgnoreCase)
&& !string.Equals(videoEncoder, "hevc_amf", StringComparison.OrdinalIgnoreCase))
{
param = "-pix_fmt yuv420p " + param;
}
if (string.Equals(videoEncoder, "h264_nvenc", StringComparison.OrdinalIgnoreCase)
|| string.Equals(videoEncoder, "h264_amf", StringComparison.OrdinalIgnoreCase)
|| string.Equals(videoEncoder, "hevc_nvenc", StringComparison.OrdinalIgnoreCase)
|| string.Equals(videoEncoder, "hevc_amf", StringComparison.OrdinalIgnoreCase))
{
var videoStream = state.VideoStream;
var isColorDepth10 = IsColorDepth10(state);
if (isColorDepth10
&& _mediaEncoder.SupportsHwaccel("opencl")
&& encodingOptions.EnableTonemapping
&& !string.IsNullOrEmpty(videoStream.VideoRange)
&& videoStream.VideoRange.Contains("HDR", StringComparison.OrdinalIgnoreCase))
{
param = "-pix_fmt nv12 " + param;
}
else
{
param = "-pix_fmt yuv420p " + param;
}
}
if (string.Equals(videoEncoder, "h264_v4l2m2m", StringComparison.OrdinalIgnoreCase))
{
param = "-pix_fmt nv21 " + param;
}
return param; return param;
} }
@ -1521,7 +1614,7 @@ namespace MediaBrowser.Controller.MediaEncoding
if (filters.Count > 0) if (filters.Count > 0)
{ {
return "-af \"" + string.Join(",", filters) + "\""; return " -af \"" + string.Join(",", filters) + "\"";
} }
return string.Empty; return string.Empty;
@ -3378,7 +3471,7 @@ namespace MediaBrowser.Controller.MediaEncoding
if (state.RunTimeTicks.HasValue && state.BaseRequest.CopyTimestamps) if (state.RunTimeTicks.HasValue && state.BaseRequest.CopyTimestamps)
{ {
args += " -copyts -avoid_negative_ts 0 -start_at_zero"; args += " -copyts -avoid_negative_ts disabled -start_at_zero";
} }
if (!state.RunTimeTicks.HasValue) if (!state.RunTimeTicks.HasValue)
@ -3426,7 +3519,7 @@ namespace MediaBrowser.Controller.MediaEncoding
args += " -copyts"; args += " -copyts";
} }
args += " -avoid_negative_ts 0"; args += " -avoid_negative_ts disabled";
if (!(state.SubtitleStream != null && state.SubtitleStream.IsExternal && !state.SubtitleStream.IsTextSubtitleStream)) if (!(state.SubtitleStream != null && state.SubtitleStream.IsExternal && !state.SubtitleStream.IsTextSubtitleStream))
{ {
@ -3490,7 +3583,7 @@ namespace MediaBrowser.Controller.MediaEncoding
args += " -ar " + state.OutputAudioSampleRate.Value.ToString(_usCulture); args += " -ar " + state.OutputAudioSampleRate.Value.ToString(_usCulture);
} }
args += " " + GetAudioFilterParam(state, encodingOptions, false); args += GetAudioFilterParam(state, encodingOptions, false);
return args; return args;
} }