2020-11-18 14:23:45 +01:00
using System ;
2020-07-31 17:09:10 +02:00
using System.Collections.Generic ;
2020-09-06 01:11:44 +02:00
using System.ComponentModel.DataAnnotations ;
2020-07-31 17:09:10 +02:00
using System.Globalization ;
using System.IO ;
2020-11-13 20:47:54 +01:00
using System.Runtime.InteropServices ;
2020-07-31 17:09:10 +02:00
using System.Threading ;
using System.Threading.Tasks ;
2020-09-02 01:26:49 +02:00
using Jellyfin.Api.Attributes ;
2020-07-31 17:09:10 +02:00
using Jellyfin.Api.Constants ;
using Jellyfin.Api.Helpers ;
using Jellyfin.Api.Models.PlaybackDtos ;
using Jellyfin.Api.Models.StreamingDtos ;
using MediaBrowser.Common.Configuration ;
using MediaBrowser.Controller.Configuration ;
using MediaBrowser.Controller.Devices ;
using MediaBrowser.Controller.Dlna ;
using MediaBrowser.Controller.Library ;
using MediaBrowser.Controller.MediaEncoding ;
using MediaBrowser.Controller.Net ;
using MediaBrowser.Model.Configuration ;
using MediaBrowser.Model.Dlna ;
using MediaBrowser.Model.IO ;
using MediaBrowser.Model.Net ;
using Microsoft.AspNetCore.Authorization ;
using Microsoft.AspNetCore.Http ;
using Microsoft.AspNetCore.Mvc ;
using Microsoft.Extensions.Configuration ;
using Microsoft.Extensions.Logging ;
namespace Jellyfin.Api.Controllers
{
/// <summary>
/// The video hls controller.
/// </summary>
2020-08-04 20:48:53 +02:00
[Route("")]
2020-07-31 17:09:10 +02:00
[Authorize(Policy = Policies.DefaultAuthorization)]
public class VideoHlsController : BaseJellyfinApiController
{
private const string DefaultEncoderPreset = "superfast" ;
2020-11-20 02:56:08 +01:00
private const TranscodingJobType TranscodingJobType = MediaBrowser . Controller . MediaEncoding . TranscodingJobType . Hls ;
2020-07-31 17:09:10 +02:00
private readonly EncodingHelper _encodingHelper ;
private readonly IDlnaManager _dlnaManager ;
private readonly IAuthorizationContext _authContext ;
private readonly IUserManager _userManager ;
private readonly ILibraryManager _libraryManager ;
private readonly IMediaSourceManager _mediaSourceManager ;
private readonly IServerConfigurationManager _serverConfigurationManager ;
private readonly IMediaEncoder _mediaEncoder ;
private readonly IDeviceManager _deviceManager ;
private readonly TranscodingJobHelper _transcodingJobHelper ;
2020-08-03 21:16:29 +02:00
private readonly ILogger < VideoHlsController > _logger ;
2020-07-31 17:09:10 +02:00
private readonly EncodingOptions _encodingOptions ;
/// <summary>
/// Initializes a new instance of the <see cref="VideoHlsController"/> class.
/// </summary>
/// <param name="mediaEncoder">Instance of the <see cref="IMediaEncoder"/> interface.</param>
/// <param name="dlnaManager">Instance of the <see cref="IDlnaManager"/> interface.</param>
/// <param name="userManger">Instance of the <see cref="IUserManager"/> interface.</param>
/// <param name="authorizationContext">Instance of the <see cref="IAuthorizationContext"/> interface.</param>
/// <param name="libraryManager">Instance of the <see cref="ILibraryManager"/> interface.</param>
/// <param name="mediaSourceManager">Instance of the <see cref="IMediaSourceManager"/> interface.</param>
/// <param name="serverConfigurationManager">Instance of the <see cref="IServerConfigurationManager"/> interface.</param>
/// <param name="deviceManager">Instance of the <see cref="IDeviceManager"/> interface.</param>
/// <param name="transcodingJobHelper">The <see cref="TranscodingJobHelper"/> singleton.</param>
/// <param name="logger">Instance of the <see cref="ILogger{VideoHlsController}"/>.</param>
2021-04-20 23:03:36 +02:00
/// <param name="encodingHelper">Instance of <see cref="EncodingHelper"/>.</param>
2020-07-31 17:09:10 +02:00
public VideoHlsController (
IMediaEncoder mediaEncoder ,
IDlnaManager dlnaManager ,
IUserManager userManger ,
IAuthorizationContext authorizationContext ,
ILibraryManager libraryManager ,
IMediaSourceManager mediaSourceManager ,
IServerConfigurationManager serverConfigurationManager ,
IDeviceManager deviceManager ,
TranscodingJobHelper transcodingJobHelper ,
2021-04-20 23:03:36 +02:00
ILogger < VideoHlsController > logger ,
EncodingHelper encodingHelper )
2020-07-31 17:09:10 +02:00
{
_dlnaManager = dlnaManager ;
_authContext = authorizationContext ;
_userManager = userManger ;
_libraryManager = libraryManager ;
_mediaSourceManager = mediaSourceManager ;
_serverConfigurationManager = serverConfigurationManager ;
_mediaEncoder = mediaEncoder ;
_deviceManager = deviceManager ;
_transcodingJobHelper = transcodingJobHelper ;
_logger = logger ;
2021-04-20 23:03:36 +02:00
_encodingHelper = encodingHelper ;
2020-07-31 17:09:10 +02:00
_encodingOptions = serverConfigurationManager . GetEncodingOptions ( ) ;
}
/// <summary>
/// Gets a hls live stream.
/// </summary>
/// <param name="itemId">The item id.</param>
/// <param name="container">The audio container.</param>
/// <param name="static">Optional. If true, the original file will be streamed statically without any encoding. Use either no url extension or the original file extension. true/false.</param>
/// <param name="params">The streaming parameters.</param>
/// <param name="tag">The tag.</param>
/// <param name="deviceProfileId">Optional. The dlna device profile id to utilize.</param>
/// <param name="playSessionId">The play session id.</param>
/// <param name="segmentContainer">The segment container.</param>
/// <param name="segmentLength">The segment lenght.</param>
/// <param name="minSegments">The minimum number of segments.</param>
/// <param name="mediaSourceId">The media version id, if playing an alternate version.</param>
/// <param name="deviceId">The device id of the client requesting. Used to stop encoding processes when needed.</param>
/// <param name="audioCodec">Optional. Specify a audio codec to encode to, e.g. mp3. If omitted the server will auto-select using the url's extension. Options: aac, mp3, vorbis, wma.</param>
/// <param name="enableAutoStreamCopy">Whether or not to allow automatic stream copy if requested values match the original source. Defaults to true.</param>
/// <param name="allowVideoStreamCopy">Whether or not to allow copying of the video stream url.</param>
/// <param name="allowAudioStreamCopy">Whether or not to allow copying of the audio stream url.</param>
/// <param name="breakOnNonKeyFrames">Optional. Whether to break on non key frames.</param>
/// <param name="audioSampleRate">Optional. Specify a specific audio sample rate, e.g. 44100.</param>
/// <param name="maxAudioBitDepth">Optional. The maximum audio bit depth.</param>
/// <param name="audioBitRate">Optional. Specify an audio bitrate to encode to, e.g. 128000. If omitted this will be left to encoder defaults.</param>
/// <param name="audioChannels">Optional. Specify a specific number of audio channels to encode to, e.g. 2.</param>
/// <param name="maxAudioChannels">Optional. Specify a maximum number of audio channels to encode to, e.g. 2.</param>
/// <param name="profile">Optional. Specify a specific an encoder profile (varies by encoder), e.g. main, baseline, high.</param>
/// <param name="level">Optional. Specify a level for the encoder profile (varies by encoder), e.g. 3, 3.1.</param>
/// <param name="framerate">Optional. A specific video framerate to encode to, e.g. 23.976. Generally this should be omitted unless the device has specific requirements.</param>
/// <param name="maxFramerate">Optional. A specific maximum video framerate to encode to, e.g. 23.976. Generally this should be omitted unless the device has specific requirements.</param>
/// <param name="copyTimestamps">Whether or not to copy timestamps when transcoding with an offset. Defaults to false.</param>
/// <param name="startTimeTicks">Optional. Specify a starting offset, in ticks. 1 tick = 10000 ms.</param>
/// <param name="width">Optional. The fixed horizontal resolution of the encoded video.</param>
/// <param name="height">Optional. The fixed vertical resolution of the encoded video.</param>
/// <param name="videoBitRate">Optional. Specify a video bitrate to encode to, e.g. 500000. If omitted this will be left to encoder defaults.</param>
/// <param name="subtitleStreamIndex">Optional. The index of the subtitle stream to use. If omitted no subtitles will be used.</param>
/// <param name="subtitleMethod">Optional. Specify the subtitle delivery method.</param>
/// <param name="maxRefFrames">Optional.</param>
/// <param name="maxVideoBitDepth">Optional. The maximum video bit depth.</param>
/// <param name="requireAvc">Optional. Whether to require avc.</param>
/// <param name="deInterlace">Optional. Whether to deinterlace the video.</param>
2020-11-18 14:23:45 +01:00
/// <param name="requireNonAnamorphic">Optional. Whether to require a non anamorphic stream.</param>
2020-07-31 17:09:10 +02:00
/// <param name="transcodingMaxAudioChannels">Optional. The maximum number of audio channels to transcode.</param>
/// <param name="cpuCoreLimit">Optional. The limit of how many cpu cores to use.</param>
/// <param name="liveStreamId">The live stream id.</param>
/// <param name="enableMpegtsM2TsMode">Optional. Whether to enable the MpegtsM2Ts mode.</param>
2021-08-20 20:22:21 +02:00
/// <param name="videoCodec">Optional. Specify a video codec to encode to, e.g. h264. If omitted the server will auto-select using the url's extension. Options: h265, h264, mpeg4, theora, vp8, vp9, vpx (deprecated), wmv.</param>
2020-07-31 17:09:10 +02:00
/// <param name="subtitleCodec">Optional. Specify a subtitle codec to encode to.</param>
2020-11-30 11:36:11 +01:00
/// <param name="transcodeReasons">Optional. The transcoding reason.</param>
2020-07-31 17:09:10 +02:00
/// <param name="audioStreamIndex">Optional. The index of the audio stream to use. If omitted the first audio stream will be used.</param>
/// <param name="videoStreamIndex">Optional. The index of the video stream to use. If omitted the first video stream will be used.</param>
/// <param name="context">Optional. The <see cref="EncodingContext"/>.</param>
/// <param name="streamOptions">Optional. The streaming options.</param>
/// <param name="maxWidth">Optional. The max width.</param>
/// <param name="maxHeight">Optional. The max height.</param>
/// <param name="enableSubtitlesInManifest">Optional. Whether to enable subtitles in the manifest.</param>
2020-07-31 17:26:14 +02:00
/// <response code="200">Hls live stream retrieved.</response>
2020-07-31 17:09:10 +02:00
/// <returns>A <see cref="FileResult"/> containing the hls file.</returns>
2020-08-04 20:48:53 +02:00
[HttpGet("Videos/{itemId}/live.m3u8")]
2020-07-31 17:09:10 +02:00
[ProducesResponseType(StatusCodes.Status200OK)]
2020-09-02 01:26:49 +02:00
[ProducesPlaylistFile]
2020-07-31 17:09:10 +02:00
public async Task < ActionResult > GetLiveHlsStream (
2020-09-06 17:07:27 +02:00
[FromRoute, Required] Guid itemId ,
2020-07-31 17:09:10 +02:00
[FromQuery] string? container ,
[FromQuery] bool? @static ,
[FromQuery] string? @params ,
[FromQuery] string? tag ,
[FromQuery] string? deviceProfileId ,
[FromQuery] string? playSessionId ,
[FromQuery] string? segmentContainer ,
[FromQuery] int? segmentLength ,
[FromQuery] int? minSegments ,
[FromQuery] string? mediaSourceId ,
[FromQuery] string? deviceId ,
[FromQuery] string? audioCodec ,
[FromQuery] bool? enableAutoStreamCopy ,
[FromQuery] bool? allowVideoStreamCopy ,
[FromQuery] bool? allowAudioStreamCopy ,
[FromQuery] bool? breakOnNonKeyFrames ,
[FromQuery] int? audioSampleRate ,
[FromQuery] int? maxAudioBitDepth ,
[FromQuery] int? audioBitRate ,
[FromQuery] int? audioChannels ,
[FromQuery] int? maxAudioChannels ,
[FromQuery] string? profile ,
[FromQuery] string? level ,
[FromQuery] float? framerate ,
[FromQuery] float? maxFramerate ,
[FromQuery] bool? copyTimestamps ,
[FromQuery] long? startTimeTicks ,
[FromQuery] int? width ,
[FromQuery] int? height ,
[FromQuery] int? videoBitRate ,
[FromQuery] int? subtitleStreamIndex ,
2021-03-05 02:25:52 +01:00
[FromQuery] SubtitleDeliveryMethod ? subtitleMethod ,
2020-07-31 17:09:10 +02:00
[FromQuery] int? maxRefFrames ,
[FromQuery] int? maxVideoBitDepth ,
[FromQuery] bool? requireAvc ,
[FromQuery] bool? deInterlace ,
[FromQuery] bool? requireNonAnamorphic ,
[FromQuery] int? transcodingMaxAudioChannels ,
[FromQuery] int? cpuCoreLimit ,
[FromQuery] string? liveStreamId ,
[FromQuery] bool? enableMpegtsM2TsMode ,
[FromQuery] string? videoCodec ,
[FromQuery] string? subtitleCodec ,
2020-11-30 11:36:11 +01:00
[FromQuery] string? transcodeReasons ,
2020-07-31 17:09:10 +02:00
[FromQuery] int? audioStreamIndex ,
[FromQuery] int? videoStreamIndex ,
2021-03-05 02:25:52 +01:00
[FromQuery] EncodingContext ? context ,
2020-07-31 17:09:10 +02:00
[FromQuery] Dictionary < string , string > streamOptions ,
[FromQuery] int? maxWidth ,
[FromQuery] int? maxHeight ,
[FromQuery] bool? enableSubtitlesInManifest )
{
VideoRequestDto streamingRequest = new VideoRequestDto
{
Id = itemId ,
Container = container ,
2021-03-22 20:53:55 +01:00
Static = @static ? ? false ,
2020-07-31 17:09:10 +02:00
Params = @params ,
Tag = tag ,
DeviceProfileId = deviceProfileId ,
PlaySessionId = playSessionId ,
SegmentContainer = segmentContainer ,
SegmentLength = segmentLength ,
MinSegments = minSegments ,
MediaSourceId = mediaSourceId ,
DeviceId = deviceId ,
AudioCodec = audioCodec ,
EnableAutoStreamCopy = enableAutoStreamCopy ? ? true ,
AllowAudioStreamCopy = allowAudioStreamCopy ? ? true ,
AllowVideoStreamCopy = allowVideoStreamCopy ? ? true ,
BreakOnNonKeyFrames = breakOnNonKeyFrames ? ? false ,
AudioSampleRate = audioSampleRate ,
MaxAudioChannels = maxAudioChannels ,
AudioBitRate = audioBitRate ,
MaxAudioBitDepth = maxAudioBitDepth ,
AudioChannels = audioChannels ,
Profile = profile ,
Level = level ,
Framerate = framerate ,
MaxFramerate = maxFramerate ,
2021-03-22 20:53:55 +01:00
CopyTimestamps = copyTimestamps ? ? false ,
2020-07-31 17:09:10 +02:00
StartTimeTicks = startTimeTicks ,
Width = width ,
Height = height ,
VideoBitRate = videoBitRate ,
SubtitleStreamIndex = subtitleStreamIndex ,
2021-03-05 02:25:52 +01:00
SubtitleMethod = subtitleMethod ? ? SubtitleDeliveryMethod . Encode ,
2020-07-31 17:09:10 +02:00
MaxRefFrames = maxRefFrames ,
MaxVideoBitDepth = maxVideoBitDepth ,
2021-03-22 20:53:55 +01:00
RequireAvc = requireAvc ? ? false ,
DeInterlace = deInterlace ? ? false ,
RequireNonAnamorphic = requireNonAnamorphic ? ? false ,
2020-07-31 17:09:10 +02:00
TranscodingMaxAudioChannels = transcodingMaxAudioChannels ,
CpuCoreLimit = cpuCoreLimit ,
LiveStreamId = liveStreamId ,
2021-03-22 20:53:55 +01:00
EnableMpegtsM2TsMode = enableMpegtsM2TsMode ? ? false ,
2020-07-31 17:09:10 +02:00
VideoCodec = videoCodec ,
SubtitleCodec = subtitleCodec ,
2020-11-30 11:36:11 +01:00
TranscodeReasons = transcodeReasons ,
2020-07-31 17:09:10 +02:00
AudioStreamIndex = audioStreamIndex ,
VideoStreamIndex = videoStreamIndex ,
2021-03-05 02:25:52 +01:00
Context = context ? ? EncodingContext . Streaming ,
2020-07-31 17:09:10 +02:00
StreamOptions = streamOptions ,
MaxHeight = maxHeight ,
MaxWidth = maxWidth ,
EnableSubtitlesInManifest = enableSubtitlesInManifest ? ? true
} ;
2021-06-04 14:36:58 +02:00
// CTS lifecycle is managed internally.
2020-07-31 17:09:10 +02:00
var cancellationTokenSource = new CancellationTokenSource ( ) ;
2020-08-04 20:48:53 +02:00
using var state = await StreamingHelpers . GetStreamingState (
2020-07-31 17:09:10 +02:00
streamingRequest ,
Request ,
_authContext ,
_mediaSourceManager ,
_userManager ,
_libraryManager ,
_serverConfigurationManager ,
_mediaEncoder ,
2021-04-20 23:03:36 +02:00
_encodingHelper ,
2020-07-31 17:09:10 +02:00
_dlnaManager ,
_deviceManager ,
_transcodingJobHelper ,
2020-11-20 02:56:08 +01:00
TranscodingJobType ,
2020-07-31 17:09:10 +02:00
cancellationTokenSource . Token )
. ConfigureAwait ( false ) ;
TranscodingJobDto ? job = null ;
2020-11-13 20:47:54 +01:00
var playlistPath = Path . ChangeExtension ( state . OutputFilePath , ".m3u8" ) ;
2020-07-31 17:09:10 +02:00
2020-11-13 20:47:54 +01:00
if ( ! System . IO . File . Exists ( playlistPath ) )
2020-07-31 17:09:10 +02:00
{
2020-11-13 20:47:54 +01:00
var transcodingLock = _transcodingJobHelper . GetTranscodingLock ( playlistPath ) ;
2020-07-31 17:09:10 +02:00
await transcodingLock . WaitAsync ( cancellationTokenSource . Token ) . ConfigureAwait ( false ) ;
try
{
2020-11-13 20:47:54 +01:00
if ( ! System . IO . File . Exists ( playlistPath ) )
2020-07-31 17:09:10 +02:00
{
// If the playlist doesn't already exist, startup ffmpeg
try
{
job = await _transcodingJobHelper . StartFfMpeg (
state ,
2020-11-13 20:47:54 +01:00
playlistPath ,
GetCommandLineArguments ( playlistPath , state ) ,
2020-07-31 17:09:10 +02:00
Request ,
2020-11-20 02:56:08 +01:00
TranscodingJobType ,
2020-07-31 17:09:10 +02:00
cancellationTokenSource )
. ConfigureAwait ( false ) ;
job . IsLiveOutput = true ;
}
catch
{
state . Dispose ( ) ;
throw ;
}
minSegments = state . MinSegments ;
if ( minSegments > 0 )
{
2020-11-13 20:47:54 +01:00
await HlsHelpers . WaitForMinimumSegmentCount ( playlistPath , minSegments , _logger , cancellationTokenSource . Token ) . ConfigureAwait ( false ) ;
2020-07-31 17:09:10 +02:00
}
}
}
finally
{
transcodingLock . Release ( ) ;
}
}
2020-11-20 02:56:08 +01:00
job ? ? = _transcodingJobHelper . OnTranscodeBeginRequest ( playlistPath , TranscodingJobType ) ;
2020-07-31 17:09:10 +02:00
if ( job ! = null )
{
_transcodingJobHelper . OnTranscodeEndRequest ( job ) ;
}
2020-11-13 20:47:54 +01:00
var playlistText = HlsHelpers . GetLivePlaylistText ( playlistPath , state ) ;
2020-07-31 17:09:10 +02:00
return Content ( playlistText , MimeTypes . GetMimeType ( "playlist.m3u8" ) ) ;
}
/// <summary>
/// Gets the command line arguments for ffmpeg.
/// </summary>
/// <param name="outputPath">The output path of the file.</param>
/// <param name="state">The <see cref="StreamState"/>.</param>
/// <returns>The command line arguments as a string.</returns>
private string GetCommandLineArguments ( string outputPath , StreamState state )
{
var videoCodec = _encodingHelper . GetVideoEncoder ( state , _encodingOptions ) ;
2020-11-18 10:54:21 +01:00
var threads = EncodingHelper . GetNumberOfThreads ( state , _encodingOptions , videoCodec ) ; // GetNumberOfThreads is static.
2020-07-31 17:09:10 +02:00
var inputModifier = _encodingHelper . GetInputModifier ( state , _encodingOptions ) ;
2020-11-13 20:47:54 +01:00
var mapArgs = state . IsOutputVideo ? _encodingHelper . GetMapArgs ( state ) : string . Empty ;
2020-07-31 17:09:10 +02:00
2020-11-14 02:04:06 +01:00
var directory = Path . GetDirectoryName ( outputPath ) ? ? throw new ArgumentException ( $"Provided path ({outputPath}) is not valid." , nameof ( outputPath ) ) ;
2020-11-13 20:47:54 +01:00
var outputFileNameWithoutExtension = Path . GetFileNameWithoutExtension ( outputPath ) ;
2020-11-16 05:36:55 +01:00
var outputPrefix = Path . Combine ( directory , outputFileNameWithoutExtension ) ;
2020-11-19 15:46:02 +01:00
var outputExtension = EncodingHelper . GetSegmentFileExtension ( state . Request . SegmentContainer ) ;
2020-11-13 20:47:54 +01:00
var outputTsArg = outputPrefix + "%d" + outputExtension ;
var segmentFormat = outputExtension . TrimStart ( '.' ) ;
2020-07-31 17:09:10 +02:00
if ( string . Equals ( segmentFormat , "ts" , StringComparison . OrdinalIgnoreCase ) )
{
segmentFormat = "mpegts" ;
}
2020-11-13 20:47:54 +01:00
else if ( string . Equals ( segmentFormat , "mp4" , StringComparison . OrdinalIgnoreCase ) )
{
var outputFmp4HeaderArg = string . Empty ;
2021-07-12 20:20:50 +02:00
if ( OperatingSystem . IsWindows ( ) )
2020-11-13 20:47:54 +01:00
{
// on Windows, the path of fmp4 header file needs to be configured
outputFmp4HeaderArg = " -hls_fmp4_init_filename \"" + outputPrefix + "-1" + outputExtension + "\"" ;
}
else
{
// on Linux/Unix, ffmpeg generate fmp4 header file to m3u8 output folder
outputFmp4HeaderArg = " -hls_fmp4_init_filename \"" + outputFileNameWithoutExtension + "-1" + outputExtension + "\"" ;
}
segmentFormat = "fmp4" + outputFmp4HeaderArg ;
}
else
{
2020-11-20 08:06:28 +01:00
_logger . LogError ( "Invalid HLS segment container: {SegmentFormat}" , segmentFormat ) ;
2020-11-13 20:47:54 +01:00
}
var maxMuxingQueueSize = _encodingOptions . MaxMuxingQueueSize > 128
? _encodingOptions . MaxMuxingQueueSize . ToString ( CultureInfo . InvariantCulture )
: "128" ;
2020-07-31 17:09:10 +02:00
var baseUrlParam = string . Format (
CultureInfo . InvariantCulture ,
2020-10-29 03:26:33 +01:00
"\"hls/{0}/\"" ,
2020-07-31 17:09:10 +02:00
Path . GetFileNameWithoutExtension ( outputPath ) ) ;
return string . Format (
CultureInfo . InvariantCulture ,
2020-11-15 18:09:14 +01:00
"{0} {1} -map_metadata -1 -map_chapters -1 -threads {2} {3} {4} {5} -copyts -avoid_negative_ts disabled -max_muxing_queue_size {6} -f hls -max_delay 5000000 -hls_time {7} -hls_segment_type {8} -start_number 0 -hls_base_url {9} -hls_playlist_type event -hls_segment_filename \"{10}\" -y \"{11}\"" ,
2020-07-31 17:09:10 +02:00
inputModifier ,
_encodingHelper . GetInputArgument ( state , _encodingOptions ) ,
threads ,
2020-11-13 20:57:37 +01:00
mapArgs ,
2020-07-31 17:09:10 +02:00
GetVideoArguments ( state ) ,
GetAudioArguments ( state ) ,
2020-11-13 20:47:54 +01:00
maxMuxingQueueSize ,
2020-07-31 17:09:10 +02:00
state . SegmentLength . ToString ( CultureInfo . InvariantCulture ) ,
segmentFormat ,
baseUrlParam ,
2020-11-13 20:47:54 +01:00
outputTsArg ,
outputPath ) . Trim ( ) ;
2020-07-31 17:09:10 +02:00
}
/// <summary>
/// Gets the audio arguments for transcoding.
/// </summary>
/// <param name="state">The <see cref="StreamState"/>.</param>
/// <returns>The command line arguments for audio transcoding.</returns>
private string GetAudioArguments ( StreamState state )
{
2020-11-13 20:47:54 +01:00
if ( state . AudioStream = = null )
{
return string . Empty ;
}
2020-07-31 17:09:10 +02:00
2020-11-13 20:47:54 +01:00
var audioCodec = _encodingHelper . GetAudioEncoder ( state ) ;
if ( ! state . IsOutputVideo )
{
if ( EncodingHelper . IsCopyCodec ( audioCodec ) )
{
2020-11-19 15:46:02 +01:00
var bitStreamArgs = EncodingHelper . GetAudioBitStreamArguments ( state , state . Request . SegmentContainer , state . MediaSource . Container ) ;
2020-11-14 07:22:15 +01:00
return "-acodec copy -strict -2" + bitStreamArgs ;
2020-11-13 20:47:54 +01:00
}
2020-11-19 15:46:02 +01:00
var audioTranscodeParams = string . Empty ;
2020-11-13 20:47:54 +01:00
2020-11-19 15:46:02 +01:00
audioTranscodeParams + = "-acodec " + audioCodec ;
2020-11-13 20:47:54 +01:00
if ( state . OutputAudioBitrate . HasValue )
{
2020-11-19 15:46:02 +01:00
audioTranscodeParams + = " -ab " + state . OutputAudioBitrate . Value . ToString ( CultureInfo . InvariantCulture ) ;
2020-11-13 20:47:54 +01:00
}
if ( state . OutputAudioChannels . HasValue )
{
2020-11-19 15:46:02 +01:00
audioTranscodeParams + = " -ac " + state . OutputAudioChannels . Value . ToString ( CultureInfo . InvariantCulture ) ;
2020-11-13 20:47:54 +01:00
}
if ( state . OutputAudioSampleRate . HasValue )
{
2020-11-19 15:46:02 +01:00
audioTranscodeParams + = " -ar " + state . OutputAudioSampleRate . Value . ToString ( CultureInfo . InvariantCulture ) ;
2020-11-13 20:47:54 +01:00
}
2020-11-19 15:46:02 +01:00
audioTranscodeParams + = " -vn" ;
return audioTranscodeParams ;
2020-11-13 20:47:54 +01:00
}
if ( EncodingHelper . IsCopyCodec ( audioCodec ) )
2020-07-31 17:09:10 +02:00
{
2020-11-19 15:46:02 +01:00
var bitStreamArgs = EncodingHelper . GetAudioBitStreamArguments ( state , state . Request . SegmentContainer , state . MediaSource . Container ) ;
2020-11-14 07:22:15 +01:00
return "-acodec copy -strict -2" + bitStreamArgs ;
2020-07-31 17:09:10 +02:00
}
2020-11-13 20:47:54 +01:00
var args = "-codec:a:0 " + audioCodec ;
2020-07-31 17:09:10 +02:00
var channels = state . OutputAudioChannels ;
if ( channels . HasValue )
{
args + = " -ac " + channels . Value ;
}
var bitrate = state . OutputAudioBitrate ;
if ( bitrate . HasValue )
{
args + = " -ab " + bitrate . Value . ToString ( CultureInfo . InvariantCulture ) ;
}
if ( state . OutputAudioSampleRate . HasValue )
{
args + = " -ar " + state . OutputAudioSampleRate . Value . ToString ( CultureInfo . InvariantCulture ) ;
}
2021-07-10 18:09:02 +02:00
args + = _encodingHelper . GetAudioFilterParam ( state , _encodingOptions ) ;
2020-07-31 17:09:10 +02:00
return args ;
}
/// <summary>
/// Gets the video arguments for transcoding.
/// </summary>
/// <param name="state">The <see cref="StreamState"/>.</param>
/// <returns>The command line arguments for video transcoding.</returns>
private string GetVideoArguments ( StreamState state )
{
2020-11-13 20:47:54 +01:00
if ( state . VideoStream = = null )
{
return string . Empty ;
}
2020-07-31 17:09:10 +02:00
if ( ! state . IsOutputVideo )
{
return string . Empty ;
}
var codec = _encodingHelper . GetVideoEncoder ( state , _encodingOptions ) ;
var args = "-codec:v:0 " + codec ;
2020-11-13 20:47:54 +01:00
// Prefer hvc1 to hev1.
if ( string . Equals ( state . ActualOutputVideoCodec , "h265" , StringComparison . OrdinalIgnoreCase )
| | string . Equals ( state . ActualOutputVideoCodec , "hevc" , StringComparison . OrdinalIgnoreCase )
| | string . Equals ( codec , "h265" , StringComparison . OrdinalIgnoreCase )
| | string . Equals ( codec , "hevc" , StringComparison . OrdinalIgnoreCase ) )
{
args + = " -tag:v:0 hvc1" ;
}
2020-07-31 17:09:10 +02:00
// if (state.EnableMpegtsM2TsMode)
// {
// args += " -mpegts_m2ts_mode 1";
// }
2020-11-13 20:47:54 +01:00
// See if we can save come cpu cycles by avoiding encoding.
if ( EncodingHelper . IsCopyCodec ( codec ) )
2020-07-31 17:09:10 +02:00
{
2020-11-13 20:47:54 +01:00
// 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 ) )
2020-07-31 17:09:10 +02:00
{
2020-11-19 15:46:02 +01:00
string bitStreamArgs = EncodingHelper . GetBitStreamArgs ( state . VideoStream ) ;
2020-07-31 17:09:10 +02:00
if ( ! string . IsNullOrEmpty ( bitStreamArgs ) )
{
args + = " " + bitStreamArgs ;
}
}
2020-11-14 08:46:17 +01:00
args + = " -start_at_zero" ;
2020-07-31 17:09:10 +02:00
}
else
{
2020-11-19 15:46:02 +01:00
args + = _encodingHelper . GetVideoQualityParam ( state , codec , _encodingOptions , DefaultEncoderPreset ) ;
2020-07-31 17:09:10 +02:00
2020-11-19 15:46:02 +01:00
// Set the key frame params for video encoding to match the hls segment time.
args + = _encodingHelper . GetHlsVideoKeyFrameArguments ( state , codec , state . SegmentLength , true , null ) ;
2020-07-31 17:09:10 +02:00
2020-11-13 20:47:54 +01:00
// Currenly b-frames in libx265 breaks the FMP4-HLS playback on iOS, disable it for now.
if ( string . Equals ( codec , "libx265" , StringComparison . OrdinalIgnoreCase ) )
{
args + = " -bf 0" ;
}
var hasGraphicalSubs = state . SubtitleStream ! = null & & ! state . SubtitleStream . IsTextSubtitleStream & & state . SubtitleDeliveryMethod = = SubtitleDeliveryMethod . Encode ;
2020-07-31 17:09:10 +02:00
if ( hasGraphicalSubs )
{
2020-11-13 20:47:54 +01:00
// Graphical subs overlay and resolution params.
2020-07-31 17:09:10 +02:00
args + = _encodingHelper . GetGraphicalSubtitleParam ( state , _encodingOptions , codec ) ;
}
2020-11-13 20:47:54 +01:00
else
{
// Resolution params.
args + = _encodingHelper . GetOutputSizeParam ( state , _encodingOptions , codec ) ;
}
2020-11-19 16:02:36 +01:00
if ( state . SubtitleStream = = null | | ! state . SubtitleStream . IsExternal | | state . SubtitleStream . IsTextSubtitleStream )
2020-11-13 20:47:54 +01:00
{
args + = " -start_at_zero" ;
}
2020-07-31 17:09:10 +02:00
}
args + = " -flags -global_header" ;
if ( ! string . IsNullOrEmpty ( state . OutputVideoSync ) )
{
args + = " -vsync " + state . OutputVideoSync ;
}
args + = _encodingHelper . GetOutputFFlags ( state ) ;
return args ;
}
}
}