2017-02-02 17:02:01 +01:00
using System ;
using System.Collections.Generic ;
using System.Globalization ;
using System.IO ;
using System.Linq ;
using System.Threading ;
2017-08-05 21:02:33 +02:00
using MediaBrowser.Controller.Entities ;
2017-02-02 17:02:01 +01:00
using MediaBrowser.Model.Configuration ;
using MediaBrowser.Model.Dlna ;
using MediaBrowser.Model.Dto ;
using MediaBrowser.Model.Entities ;
using MediaBrowser.Model.IO ;
using MediaBrowser.Model.MediaInfo ;
2017-08-04 22:29:34 +02:00
using MediaBrowser.Model.Extensions ;
2017-02-02 17:02:01 +01:00
2017-02-19 04:46:09 +01:00
namespace MediaBrowser.Controller.MediaEncoding
2017-02-02 17:02:01 +01:00
{
public class EncodingHelper
{
private readonly CultureInfo _usCulture = new CultureInfo ( "en-US" ) ;
private readonly IMediaEncoder _mediaEncoder ;
private readonly IFileSystem _fileSystem ;
private readonly ISubtitleEncoder _subtitleEncoder ;
2017-08-01 21:43:39 +02:00
public EncodingHelper ( IMediaEncoder mediaEncoder , IFileSystem fileSystem , ISubtitleEncoder subtitleEncoder )
2017-02-02 17:02:01 +01:00
{
_mediaEncoder = mediaEncoder ;
_fileSystem = fileSystem ;
_subtitleEncoder = subtitleEncoder ;
}
public string GetH264Encoder ( EncodingJobInfo state , EncodingOptions encodingOptions )
{
var defaultEncoder = "libx264" ;
// Only use alternative encoders for video files.
// When using concat with folder rips, if the mfx session fails to initialize, ffmpeg will be stuck retrying and will not exit gracefully
// Since transcoding of folder rips is expiremental anyway, it's not worth adding additional variables such as this.
if ( state . VideoType = = VideoType . VideoFile )
{
var hwType = encodingOptions . HardwareAccelerationType ;
2017-06-12 08:11:19 +02:00
if ( ! encodingOptions . EnableHardwareEncoding )
{
hwType = null ;
}
2017-02-02 17:02:01 +01:00
if ( string . Equals ( hwType , "qsv" , StringComparison . OrdinalIgnoreCase ) | |
string . Equals ( hwType , "h264_qsv" , StringComparison . OrdinalIgnoreCase ) )
{
return GetAvailableEncoder ( "h264_qsv" , defaultEncoder ) ;
}
if ( string . Equals ( hwType , "nvenc" , StringComparison . OrdinalIgnoreCase ) )
{
return GetAvailableEncoder ( "h264_nvenc" , defaultEncoder ) ;
}
2017-09-15 19:57:42 +02:00
if ( string . Equals ( hwType , "omx" , StringComparison . OrdinalIgnoreCase ) )
2017-02-02 17:02:01 +01:00
{
return GetAvailableEncoder ( "h264_omx" , defaultEncoder ) ;
}
2017-09-10 20:35:23 +02:00
if ( string . Equals ( hwType , "h264_v4l2m2m" , StringComparison . OrdinalIgnoreCase ) )
{
return GetAvailableEncoder ( "h264_v4l2m2m" , defaultEncoder ) ;
}
2017-02-02 17:02:01 +01:00
if ( string . Equals ( hwType , "vaapi" , StringComparison . OrdinalIgnoreCase ) & & ! string . IsNullOrWhiteSpace ( encodingOptions . VaapiDevice ) )
{
if ( IsVaapiSupported ( state ) )
{
return GetAvailableEncoder ( "h264_vaapi" , defaultEncoder ) ;
}
}
}
return defaultEncoder ;
}
private string GetAvailableEncoder ( string preferredEncoder , string defaultEncoder )
{
if ( _mediaEncoder . SupportsEncoder ( preferredEncoder ) )
{
return preferredEncoder ;
}
return defaultEncoder ;
}
private bool IsVaapiSupported ( EncodingJobInfo state )
{
var videoStream = state . VideoStream ;
if ( videoStream ! = null )
{
// vaapi will throw an error with this input
// [vaapi @ 0x7faed8000960] No VAAPI support for codec mpeg4 profile -99.
if ( string . Equals ( videoStream . Codec , "mpeg4" , StringComparison . OrdinalIgnoreCase ) )
{
2017-02-24 05:23:56 +01:00
return false ;
2017-02-02 17:02:01 +01:00
}
}
return true ;
}
/// <summary>
/// Gets the name of the output video codec
/// </summary>
public string GetVideoEncoder ( EncodingJobInfo state , EncodingOptions encodingOptions )
{
var codec = state . OutputVideoCodec ;
if ( ! string . IsNullOrEmpty ( codec ) )
{
if ( string . Equals ( codec , "h264" , StringComparison . OrdinalIgnoreCase ) )
{
return GetH264Encoder ( state , encodingOptions ) ;
}
if ( string . Equals ( codec , "vpx" , StringComparison . OrdinalIgnoreCase ) )
{
return "libvpx" ;
}
if ( string . Equals ( codec , "wmv" , StringComparison . OrdinalIgnoreCase ) )
{
return "wmv2" ;
}
if ( string . Equals ( codec , "theora" , StringComparison . OrdinalIgnoreCase ) )
{
return "libtheora" ;
}
return codec . ToLower ( ) ;
}
return "copy" ;
}
/// <summary>
/// Gets the user agent param.
/// </summary>
/// <param name="state">The state.</param>
/// <returns>System.String.</returns>
public string GetUserAgentParam ( EncodingJobInfo state )
{
string useragent = null ;
state . RemoteHttpHeaders . TryGetValue ( "User-Agent" , out useragent ) ;
if ( ! string . IsNullOrWhiteSpace ( useragent ) )
{
return "-user-agent \"" + useragent + "\"" ;
}
return string . Empty ;
}
public string GetInputFormat ( string container )
{
2017-08-04 22:29:34 +02:00
if ( string . IsNullOrWhiteSpace ( container ) )
2017-02-02 17:02:01 +01:00
{
2017-08-04 22:29:34 +02:00
return null ;
2017-02-02 17:02:01 +01:00
}
2017-08-04 22:29:34 +02:00
container = container . Replace ( "mkv" , "matroska" , StringComparison . OrdinalIgnoreCase ) ;
2017-02-06 07:03:01 +01:00
if ( string . Equals ( container , "ts" , StringComparison . OrdinalIgnoreCase ) )
{
return "mpegts" ;
}
2017-03-23 20:10:10 +01:00
2017-02-26 22:47:52 +01:00
// For these need to find out the ffmpeg names
if ( string . Equals ( container , "m2ts" , StringComparison . OrdinalIgnoreCase ) )
{
return null ;
}
if ( string . Equals ( container , "wmv" , StringComparison . OrdinalIgnoreCase ) )
{
return null ;
}
2017-03-28 19:32:24 +02:00
if ( string . Equals ( container , "mts" , StringComparison . OrdinalIgnoreCase ) )
{
return null ;
}
2017-02-26 22:47:52 +01:00
if ( string . Equals ( container , "vob" , StringComparison . OrdinalIgnoreCase ) )
{
return null ;
}
2017-03-01 21:29:42 +01:00
if ( string . Equals ( container , "mpg" , StringComparison . OrdinalIgnoreCase ) )
{
return null ;
}
if ( string . Equals ( container , "mpeg" , StringComparison . OrdinalIgnoreCase ) )
{
return null ;
}
2017-03-03 21:16:43 +01:00
if ( string . Equals ( container , "rec" , StringComparison . OrdinalIgnoreCase ) )
{
return null ;
}
2017-03-23 20:10:10 +01:00
if ( string . Equals ( container , "dvr-ms" , StringComparison . OrdinalIgnoreCase ) )
{
return null ;
}
2017-03-31 21:50:55 +02:00
if ( string . Equals ( container , "ogm" , StringComparison . OrdinalIgnoreCase ) )
{
return null ;
}
if ( string . Equals ( container , "divx" , StringComparison . OrdinalIgnoreCase ) )
{
return null ;
}
2017-06-27 22:56:47 +02:00
if ( string . Equals ( container , "tp" , StringComparison . OrdinalIgnoreCase ) )
{
return null ;
}
2017-07-25 20:32:03 +02:00
if ( string . Equals ( container , "rmvb" , StringComparison . OrdinalIgnoreCase ) )
{
return null ;
}
2017-08-13 22:15:07 +02:00
if ( string . Equals ( container , "rtp" , StringComparison . OrdinalIgnoreCase ) )
{
return null ;
}
2017-03-23 20:10:10 +01:00
2017-03-07 19:27:56 +01:00
// Seeing reported failures here, not sure yet if this is related to specfying input format
if ( string . Equals ( container , "m4v" , StringComparison . OrdinalIgnoreCase ) )
{
return null ;
}
2017-02-02 17:02:01 +01:00
2017-03-13 21:42:21 +01:00
// obviously don't do this for strm files
if ( string . Equals ( container , "strm" , StringComparison . OrdinalIgnoreCase ) )
{
return null ;
}
2017-02-02 17:02:01 +01:00
return container ;
}
public string GetDecoderFromCodec ( string codec )
{
2017-03-01 21:29:42 +01:00
// For these need to find out the ffmpeg names
2017-02-02 17:02:01 +01:00
if ( string . Equals ( codec , "mp2" , StringComparison . OrdinalIgnoreCase ) )
{
return null ;
}
if ( string . Equals ( codec , "aac_latm" , StringComparison . OrdinalIgnoreCase ) )
{
return null ;
}
2017-03-01 21:29:42 +01:00
if ( string . Equals ( codec , "eac3" , StringComparison . OrdinalIgnoreCase ) )
{
return null ;
}
2017-02-02 17:02:01 +01:00
2017-06-13 08:33:29 +02:00
if ( _mediaEncoder . SupportsDecoder ( codec ) )
{
return codec ;
}
return null ;
2017-02-02 17:02:01 +01:00
}
/// <summary>
/// Infers the audio codec based on the url
/// </summary>
/// <param name="url">The URL.</param>
/// <returns>System.Nullable{AudioCodecs}.</returns>
public string InferAudioCodec ( string url )
{
var ext = Path . GetExtension ( url ) ;
if ( string . Equals ( ext , ".mp3" , StringComparison . OrdinalIgnoreCase ) )
{
return "mp3" ;
}
if ( string . Equals ( ext , ".aac" , StringComparison . OrdinalIgnoreCase ) )
{
return "aac" ;
}
if ( string . Equals ( ext , ".wma" , StringComparison . OrdinalIgnoreCase ) )
{
return "wma" ;
}
if ( string . Equals ( ext , ".ogg" , StringComparison . OrdinalIgnoreCase ) )
{
return "vorbis" ;
}
if ( string . Equals ( ext , ".oga" , StringComparison . OrdinalIgnoreCase ) )
{
return "vorbis" ;
}
if ( string . Equals ( ext , ".ogv" , StringComparison . OrdinalIgnoreCase ) )
{
return "vorbis" ;
}
if ( string . Equals ( ext , ".webm" , StringComparison . OrdinalIgnoreCase ) )
{
return "vorbis" ;
}
if ( string . Equals ( ext , ".webma" , StringComparison . OrdinalIgnoreCase ) )
{
return "vorbis" ;
}
return "copy" ;
}
/// <summary>
/// Infers the video codec.
/// </summary>
/// <param name="url">The URL.</param>
/// <returns>System.Nullable{VideoCodecs}.</returns>
public string InferVideoCodec ( string url )
{
var ext = Path . GetExtension ( url ) ;
if ( string . Equals ( ext , ".asf" , StringComparison . OrdinalIgnoreCase ) )
{
return "wmv" ;
}
if ( string . Equals ( ext , ".webm" , StringComparison . OrdinalIgnoreCase ) )
{
return "vpx" ;
}
if ( string . Equals ( ext , ".ogg" , StringComparison . OrdinalIgnoreCase ) | | string . Equals ( ext , ".ogv" , StringComparison . OrdinalIgnoreCase ) )
{
return "theora" ;
}
if ( string . Equals ( ext , ".m3u8" , StringComparison . OrdinalIgnoreCase ) | | string . Equals ( ext , ".ts" , StringComparison . OrdinalIgnoreCase ) )
{
return "h264" ;
}
return "copy" ;
}
public 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 ) ) ;
}
public string GetInputPathArgument ( EncodingJobInfo state )
{
var protocol = state . InputProtocol ;
var mediaPath = state . MediaPath ? ? string . Empty ;
var inputPath = new [ ] { mediaPath } ;
if ( state . IsInputVideo )
{
if ( ! ( state . VideoType = = VideoType . Iso & & state . IsoMount = = null ) )
{
inputPath = MediaEncoderHelpers . GetInputArgument ( _fileSystem , mediaPath , state . InputProtocol , state . IsoMount , state . PlayableStreamFileNames ) ;
}
}
return _mediaEncoder . GetInputArgument ( inputPath , protocol ) ;
}
/// <summary>
/// Gets the audio encoder.
/// </summary>
/// <param name="state">The state.</param>
/// <returns>System.String.</returns>
public string GetAudioEncoder ( EncodingJobInfo state )
{
var codec = state . OutputAudioCodec ;
if ( string . Equals ( codec , "aac" , StringComparison . OrdinalIgnoreCase ) )
{
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" ;
}
return codec . ToLower ( ) ;
}
/// <summary>
/// Gets the input argument.
/// </summary>
public string GetInputArgument ( EncodingJobInfo state , EncodingOptions encodingOptions )
{
var request = state . BaseRequest ;
var arg = string . Format ( "-i {0}" , GetInputPathArgument ( state ) ) ;
2017-04-04 07:20:07 +02:00
if ( state . SubtitleStream ! = null & & state . SubtitleDeliveryMethod = = SubtitleDeliveryMethod . Encode )
2017-02-02 17:02:01 +01:00
{
if ( state . SubtitleStream . IsExternal & & ! state . SubtitleStream . IsTextSubtitleStream )
{
if ( state . VideoStream ! = null & & state . VideoStream . Width . HasValue )
{
// This is hacky but not sure how to get the exact subtitle resolution
double height = state . VideoStream . Width . Value ;
height / = 16 ;
height * = 9 ;
arg + = string . Format ( " -canvas_size {0}:{1}" , state . VideoStream . Width . Value . ToString ( CultureInfo . InvariantCulture ) , Convert . ToInt32 ( height ) . ToString ( CultureInfo . InvariantCulture ) ) ;
}
var subtitlePath = state . SubtitleStream . Path ;
if ( string . Equals ( Path . GetExtension ( subtitlePath ) , ".sub" , StringComparison . OrdinalIgnoreCase ) )
{
var idxFile = Path . ChangeExtension ( subtitlePath , ".idx" ) ;
if ( _fileSystem . FileExists ( idxFile ) )
{
subtitlePath = idxFile ;
}
}
arg + = " -i \"" + subtitlePath + "\"" ;
}
}
if ( state . IsVideoRequest )
{
if ( GetVideoEncoder ( state , encodingOptions ) . IndexOf ( "vaapi" , StringComparison . OrdinalIgnoreCase ) ! = - 1 )
{
2017-04-04 07:20:07 +02:00
var hasGraphicalSubs = state . SubtitleStream ! = null & & ! state . SubtitleStream . IsTextSubtitleStream & & state . SubtitleDeliveryMethod = = SubtitleDeliveryMethod . Encode ;
2017-02-02 17:02:01 +01:00
var hwOutputFormat = "vaapi" ;
if ( hasGraphicalSubs )
{
hwOutputFormat = "yuv420p" ;
}
arg = "-hwaccel vaapi -hwaccel_output_format " + hwOutputFormat + " -vaapi_device " + encodingOptions . VaapiDevice + " " + arg ;
}
}
return arg . Trim ( ) ;
}
/// <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>
public bool IsH264 ( MediaStream stream )
{
var codec = stream . Codec ? ? string . Empty ;
return codec . IndexOf ( "264" , StringComparison . OrdinalIgnoreCase ) ! = - 1 | |
codec . IndexOf ( "avc" , StringComparison . OrdinalIgnoreCase ) ! = - 1 ;
}
public string GetVideoBitrateParam ( EncodingJobInfo state , string videoCodec )
{
var bitrate = state . OutputVideoBitrate ;
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 ) ) ;
}
if ( string . Equals ( videoCodec , "msmpeg4" , StringComparison . OrdinalIgnoreCase ) )
{
return string . Format ( " -b:v {0}" , bitrate . Value . ToString ( _usCulture ) ) ;
}
if ( string . Equals ( videoCodec , "libx264" , StringComparison . OrdinalIgnoreCase ) )
{
// h264
return string . Format ( " -maxrate {0} -bufsize {1}" ,
bitrate . Value . ToString ( _usCulture ) ,
( bitrate . Value * 2 ) . ToString ( _usCulture ) ) ;
}
// h264
return string . Format ( " -b:v {0} -maxrate {0} -bufsize {1}" ,
bitrate . Value . ToString ( _usCulture ) ,
( bitrate . Value * 2 ) . ToString ( _usCulture ) ) ;
}
return string . Empty ;
}
public string NormalizeTranscodingLevel ( string videoCodec , string level )
{
double requestLevel ;
// Clients may direct play higher than level 41, but there's no reason to transcode higher
if ( double . TryParse ( level , NumberStyles . Any , _usCulture , out requestLevel ) )
{
if ( string . Equals ( videoCodec , "h264" , StringComparison . OrdinalIgnoreCase ) )
{
if ( requestLevel > 41 )
{
return "41" ;
}
}
}
return level ;
}
/// <summary>
/// Gets the text subtitle param.
/// </summary>
/// <param name="state">The state.</param>
/// <returns>System.String.</returns>
public string GetTextSubtitleParam ( EncodingJobInfo state )
{
var seconds = Math . Round ( TimeSpan . FromTicks ( state . StartTimeTicks ? ? 0 ) . TotalSeconds ) ;
var setPtsParam = state . CopyTimestamps
? string . Empty
: string . Format ( ",setpts=PTS -{0}/TB" , seconds . ToString ( _usCulture ) ) ;
if ( state . SubtitleStream . IsExternal )
{
var subtitlePath = state . SubtitleStream . Path ;
var charsetParam = string . Empty ;
if ( ! string . IsNullOrEmpty ( state . SubtitleStream . Language ) )
{
var charenc = _subtitleEncoder . GetSubtitleFileCharacterSet ( subtitlePath , state . SubtitleStream . Language , state . MediaSource . Protocol , CancellationToken . None ) . Result ;
if ( ! string . IsNullOrEmpty ( charenc ) )
{
charsetParam = ":charenc=" + charenc ;
}
}
// TODO: Perhaps also use original_size=1920x800 ??
return string . Format ( "subtitles=filename='{0}'{1}{2}" ,
_mediaEncoder . EscapeSubtitleFilterPath ( subtitlePath ) ,
charsetParam ,
setPtsParam ) ;
}
var mediaPath = state . MediaPath ? ? string . Empty ;
return string . Format ( "subtitles='{0}:si={1}'{2}" ,
_mediaEncoder . EscapeSubtitleFilterPath ( mediaPath ) ,
state . InternalSubtitleStreamOffset . ToString ( _usCulture ) ,
setPtsParam ) ;
}
public double? GetFramerateParam ( EncodingJobInfo state )
{
var request = state . BaseRequest ;
if ( request . Framerate . HasValue )
{
return request . Framerate . Value ;
}
var maxrate = request . MaxFramerate ;
if ( maxrate . HasValue & & state . VideoStream ! = null )
{
var contentRate = state . VideoStream . AverageFrameRate ? ? state . VideoStream . RealFrameRate ;
if ( contentRate . HasValue & & contentRate . Value > maxrate . Value )
{
return maxrate ;
}
}
return null ;
}
/// <summary>
/// Gets the video bitrate to specify on the command line
/// </summary>
public string GetVideoQualityParam ( EncodingJobInfo state , string videoEncoder , EncodingOptions encodingOptions , string defaultH264Preset )
{
var param = string . Empty ;
var isVc1 = state . VideoStream ! = null & &
string . Equals ( state . VideoStream . Codec , "vc1" , StringComparison . OrdinalIgnoreCase ) ;
if ( string . Equals ( videoEncoder , "libx264" , StringComparison . OrdinalIgnoreCase ) )
{
if ( ! string . IsNullOrWhiteSpace ( encodingOptions . H264Preset ) )
{
param + = "-preset " + encodingOptions . H264Preset ;
}
else
{
param + = "-preset " + defaultH264Preset ;
}
if ( encodingOptions . H264Crf > = 0 & & encodingOptions . H264Crf < = 51 )
{
param + = " -crf " + encodingOptions . H264Crf . ToString ( CultureInfo . InvariantCulture ) ;
}
else
{
param + = " -crf 23" ;
}
}
else if ( string . Equals ( videoEncoder , "libx265" , StringComparison . OrdinalIgnoreCase ) )
{
param + = "-preset fast" ;
param + = " -crf 28" ;
}
// h264 (h264_qsv)
else if ( string . Equals ( videoEncoder , "h264_qsv" , StringComparison . OrdinalIgnoreCase ) )
{
param + = "-preset 7 -look_ahead 0" ;
}
// h264 (h264_nvenc)
else if ( string . Equals ( videoEncoder , "h264_nvenc" , StringComparison . OrdinalIgnoreCase ) )
{
param + = "-preset default" ;
}
// webm
else if ( string . Equals ( videoEncoder , "libvpx" , StringComparison . OrdinalIgnoreCase ) )
{
// Values 0-3, 0 being highest quality but slower
var profileScore = 0 ;
string crf ;
var qmin = "0" ;
var qmax = "50" ;
crf = "10" ;
if ( isVc1 )
{
profileScore + + ;
}
// Max of 2
profileScore = Math . Min ( profileScore , 2 ) ;
// http://www.webmproject.org/docs/encoder-parameters/
param + = string . Format ( "-speed 16 -quality good -profile:v {0} -slices 8 -crf {1} -qmin {2} -qmax {3}" ,
profileScore . ToString ( _usCulture ) ,
crf ,
qmin ,
qmax ) ;
}
else if ( string . Equals ( videoEncoder , "mpeg4" , StringComparison . OrdinalIgnoreCase ) )
{
param + = "-mbd rd -flags +mv4+aic -trellis 2 -cmp 2 -subcmp 2 -bf 2" ;
}
// asf/wmv
else if ( string . Equals ( videoEncoder , "wmv2" , StringComparison . OrdinalIgnoreCase ) )
{
param + = "-qmin 2" ;
}
else if ( string . Equals ( videoEncoder , "msmpeg4" , StringComparison . OrdinalIgnoreCase ) )
{
param + = "-mbd 2" ;
}
param + = GetVideoBitrateParam ( state , videoEncoder ) ;
var framerate = GetFramerateParam ( state ) ;
if ( framerate . HasValue )
{
param + = string . Format ( " -r {0}" , framerate . Value . ToString ( _usCulture ) ) ;
}
2017-09-25 07:06:15 +02:00
var targetVideoCodec = state . ActualOutputVideoCodec ;
2017-02-02 17:02:01 +01:00
2017-09-25 07:06:15 +02:00
var request = state . BaseRequest ;
var profile = state . GetRequestedProfiles ( targetVideoCodec ) . FirstOrDefault ( ) ;
if ( ! string . IsNullOrEmpty ( profile ) )
2017-02-02 17:02:01 +01:00
{
if ( ! string . Equals ( videoEncoder , "h264_omx" , StringComparison . OrdinalIgnoreCase ) & &
2017-09-10 20:35:23 +02:00
! string . Equals ( videoEncoder , "h264_vaapi" , StringComparison . OrdinalIgnoreCase ) & &
! string . Equals ( videoEncoder , "h264_v4l2m2m" , StringComparison . OrdinalIgnoreCase ) )
2017-02-02 17:02:01 +01:00
{
// not supported by h264_omx
2017-09-25 07:06:15 +02:00
param + = " -profile:v " + profile ;
2017-02-02 17:02:01 +01:00
}
}
2017-09-25 07:06:15 +02:00
var level = state . GetRequestedLevel ( targetVideoCodec ) ;
if ( ! string . IsNullOrEmpty ( level ) )
2017-02-02 17:02:01 +01:00
{
2017-09-25 07:06:15 +02:00
level = NormalizeTranscodingLevel ( state . OutputVideoCodec , level ) ;
2017-02-02 17:02:01 +01:00
// h264_qsv and h264_nvenc expect levels to be expressed as a decimal. libx264 supports decimal and non-decimal format
2017-03-05 13:35:23 +01:00
// also needed for libx264 due to https://trac.ffmpeg.org/ticket/3307
2017-02-02 17:02:01 +01:00
if ( string . Equals ( videoEncoder , "h264_qsv" , StringComparison . OrdinalIgnoreCase ) | |
string . Equals ( videoEncoder , "libx264" , StringComparison . OrdinalIgnoreCase ) )
{
switch ( level )
{
case "30" :
param + = " -level 3.0" ;
break ;
case "31" :
param + = " -level 3.1" ;
break ;
case "32" :
param + = " -level 3.2" ;
break ;
case "40" :
param + = " -level 4.0" ;
break ;
case "41" :
param + = " -level 4.1" ;
break ;
case "42" :
param + = " -level 4.2" ;
break ;
case "50" :
param + = " -level 5.0" ;
break ;
case "51" :
param + = " -level 5.1" ;
break ;
case "52" :
param + = " -level 5.2" ;
break ;
default :
param + = " -level " + level ;
break ;
}
}
2017-03-05 13:35:23 +01:00
// nvenc doesn't decode with param -level set ?!
2017-04-15 21:45:33 +02:00
else if ( string . Equals ( videoEncoder , "h264_nvenc" , StringComparison . OrdinalIgnoreCase ) )
{
2017-04-13 20:57:57 +02:00
//param += "";
2017-03-05 13:35:23 +01:00
}
2017-02-02 17:02:01 +01:00
else if ( ! string . Equals ( videoEncoder , "h264_omx" , StringComparison . OrdinalIgnoreCase ) )
{
param + = " -level " + level ;
}
}
if ( string . Equals ( videoEncoder , "libx264" , StringComparison . OrdinalIgnoreCase ) )
{
2017-04-22 21:32:24 +02:00
param + = " -x264opts:0 subme=0:me_range=4:rc_lookahead=10:me=dia:no_chroma_me:8x8dct=0:partitions=none" ;
2017-02-02 17:02:01 +01:00
}
if ( ! string . Equals ( videoEncoder , "h264_omx" , StringComparison . OrdinalIgnoreCase ) & &
! string . Equals ( videoEncoder , "h264_qsv" , StringComparison . OrdinalIgnoreCase ) & &
2017-09-10 20:35:23 +02:00
! string . Equals ( videoEncoder , "h264_vaapi" , StringComparison . OrdinalIgnoreCase ) & &
! string . Equals ( videoEncoder , "h264_v4l2m2m" , StringComparison . OrdinalIgnoreCase ) )
2017-02-02 17:02:01 +01:00
{
param = "-pix_fmt yuv420p " + param ;
}
2017-09-10 20:35:23 +02:00
if ( string . Equals ( videoEncoder , "h264_v4l2m2m" , StringComparison . OrdinalIgnoreCase ) )
{
param = "-pix_fmt nv21 " + param ;
}
2017-02-02 17:02:01 +01:00
return param ;
}
public bool CanStreamCopyVideo ( EncodingJobInfo state , MediaStream videoStream )
{
var request = state . BaseRequest ;
2017-03-31 21:50:55 +02:00
if ( ! request . AllowVideoStreamCopy )
{
return false ;
}
2017-08-23 20:44:40 +02:00
if ( state . EnableMpDecimate )
{
return false ;
}
2017-02-02 17:02:01 +01:00
if ( videoStream . IsInterlaced )
{
2017-09-27 16:52:01 +02:00
if ( state . DeInterlace ( videoStream . Codec , false ) )
2017-03-15 20:57:18 +01:00
{
return false ;
}
2017-02-02 17:02:01 +01:00
}
if ( videoStream . IsAnamorphic ? ? false )
{
2017-03-15 20:57:18 +01:00
if ( request . RequireNonAnamorphic )
{
return false ;
}
2017-02-02 17:02:01 +01:00
}
// Can't stream copy if we're burning in subtitles
if ( request . SubtitleStreamIndex . HasValue )
{
2017-04-04 07:20:07 +02:00
if ( state . SubtitleDeliveryMethod = = SubtitleDeliveryMethod . Encode )
2017-02-02 17:02:01 +01:00
{
return false ;
}
}
if ( string . Equals ( "h264" , videoStream . Codec , StringComparison . OrdinalIgnoreCase ) )
{
if ( videoStream . IsAVC . HasValue & & ! videoStream . IsAVC . Value & & request . RequireAvc )
{
return false ;
}
}
// Source and target codecs must match
if ( string . IsNullOrEmpty ( videoStream . Codec ) | | ! state . SupportedVideoCodecs . Contains ( videoStream . Codec , StringComparer . OrdinalIgnoreCase ) )
{
return false ;
}
2017-09-25 07:06:15 +02:00
var requestedProfiles = state . GetRequestedProfiles ( videoStream . Codec ) ;
2017-02-02 17:02:01 +01:00
// If client is requesting a specific video profile, it must match the source
2017-09-25 07:06:15 +02:00
if ( requestedProfiles . Length > 0 )
2017-02-02 17:02:01 +01:00
{
if ( string . IsNullOrEmpty ( videoStream . Profile ) )
{
//return false;
}
2017-09-25 07:06:15 +02:00
var requestedProfile = requestedProfiles [ 0 ] ;
if ( ! string . IsNullOrEmpty ( videoStream . Profile ) & & ! string . Equals ( requestedProfile , videoStream . Profile , StringComparison . OrdinalIgnoreCase ) )
2017-02-02 17:02:01 +01:00
{
var currentScore = GetVideoProfileScore ( videoStream . Profile ) ;
2017-09-25 07:06:15 +02:00
var requestedScore = GetVideoProfileScore ( requestedProfile ) ;
2017-02-02 17:02:01 +01:00
if ( currentScore = = - 1 | | currentScore > requestedScore )
{
return false ;
}
}
}
// 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 ;
}
}
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 ;
}
}
// If a specific level was requested, the source must match or be less than
2017-09-25 07:06:15 +02:00
var level = state . GetRequestedLevel ( videoStream . Codec ) ;
if ( ! string . IsNullOrEmpty ( level ) )
2017-02-02 17:02:01 +01:00
{
double requestLevel ;
2017-09-25 07:06:15 +02:00
if ( double . TryParse ( level , NumberStyles . Any , _usCulture , out requestLevel ) )
2017-02-02 17:02:01 +01:00
{
if ( ! videoStream . Level . HasValue )
{
//return false;
}
if ( videoStream . Level . HasValue & & videoStream . Level . Value > requestLevel )
{
return false ;
}
}
}
return request . EnableAutoStreamCopy ;
}
public bool CanStreamCopyAudio ( EncodingJobInfo state , MediaStream audioStream , List < string > supportedAudioCodecs )
{
var request = state . BaseRequest ;
2017-03-31 21:50:55 +02:00
if ( ! request . AllowAudioStreamCopy )
{
return false ;
}
2017-02-02 17:02:01 +01:00
// Source and target codecs must match
if ( string . IsNullOrEmpty ( audioStream . Codec ) | | ! supportedAudioCodecs . Contains ( audioStream . Codec , StringComparer . OrdinalIgnoreCase ) )
{
return false ;
}
// Channels must fall within requested value
var channels = request . AudioChannels ? ? request . MaxAudioChannels ;
if ( channels . HasValue )
{
if ( ! audioStream . Channels . HasValue | | audioStream . Channels . Value < = 0 )
{
return false ;
}
if ( audioStream . Channels . Value > channels . Value )
{
return false ;
}
}
// Sample rate must fall within requested value
if ( request . AudioSampleRate . HasValue )
{
if ( ! audioStream . SampleRate . HasValue | | audioStream . SampleRate . Value < = 0 )
{
return false ;
}
if ( audioStream . SampleRate . Value > request . AudioSampleRate . Value )
{
return false ;
}
}
2017-08-13 04:09:07 +02:00
// Video bitrate must fall within requested value
if ( request . AudioBitRate . HasValue )
{
if ( ! audioStream . BitRate . HasValue | | audioStream . BitRate . Value < = 0 )
{
return false ;
}
if ( audioStream . BitRate . Value > request . AudioBitRate . Value )
{
return false ;
}
}
2017-02-02 17:02:01 +01:00
return request . EnableAutoStreamCopy ;
}
public int? GetVideoBitrateParamValue ( BaseEncodingJobOptions request , MediaStream videoStream , string outputVideoCodec )
{
var bitrate = request . VideoBitRate ;
if ( videoStream ! = null )
{
var isUpscaling = request . Height . HasValue & & videoStream . Height . HasValue & &
request . Height . Value > videoStream . Height . Value ;
if ( request . Width . HasValue & & videoStream . Width . HasValue & &
request . Width . Value > videoStream . Width . Value )
{
isUpscaling = true ;
}
// Don't allow bitrate increases unless upscaling
if ( ! isUpscaling )
{
if ( bitrate . HasValue & & videoStream . BitRate . HasValue )
{
2017-05-17 20:18:18 +02:00
bitrate = GetMinBitrate ( bitrate . Value , videoStream . BitRate . Value ) ;
2017-02-02 17:02:01 +01:00
}
}
}
if ( bitrate . HasValue )
{
var inputVideoCodec = videoStream = = null ? null : videoStream . Codec ;
bitrate = ResolutionNormalizer . ScaleBitrate ( bitrate . Value , inputVideoCodec , outputVideoCodec ) ;
// If a max bitrate was requested, don't let the scaled bitrate exceed it
if ( request . VideoBitRate . HasValue )
{
2017-05-17 20:18:18 +02:00
bitrate = GetMinBitrate ( bitrate . Value , request . VideoBitRate . Value ) ;
2017-02-02 17:02:01 +01:00
}
}
return bitrate ;
}
2017-05-17 20:18:18 +02:00
private int GetMinBitrate ( int sourceBitrate , int requestedBitrate )
{
if ( sourceBitrate < = 2000000 )
{
2017-09-19 22:08:34 +02:00
sourceBitrate = Convert . ToInt32 ( sourceBitrate * 2.5 ) ;
2017-05-17 20:18:18 +02:00
}
2017-05-24 21:12:55 +02:00
else if ( sourceBitrate < = 3000000 )
{
2017-09-19 22:08:34 +02:00
sourceBitrate = Convert . ToInt32 ( sourceBitrate * 2 ) ;
2017-05-24 21:12:55 +02:00
}
2017-05-17 20:18:18 +02:00
var bitrate = Math . Min ( sourceBitrate , requestedBitrate ) ;
return bitrate ;
}
2017-02-02 17:02:01 +01:00
public int? GetAudioBitrateParam ( BaseEncodingJobOptions request , MediaStream audioStream )
{
if ( request . AudioBitRate . HasValue )
{
// Make sure we don't request a bitrate higher than the source
var currentBitrate = audioStream = = null ? request . AudioBitRate . Value : audioStream . BitRate ? ? request . AudioBitRate . Value ;
// Don't encode any higher than this
return Math . Min ( 384000 , request . AudioBitRate . Value ) ;
//return Math.Min(currentBitrate, request.AudioBitRate.Value);
}
return null ;
}
public string GetAudioFilterParam ( EncodingJobInfo state , EncodingOptions encodingOptions , bool isHls )
{
var channels = state . OutputAudioChannels ;
2017-04-15 21:45:33 +02:00
var filters = new List < string > ( ) ;
2017-02-02 17:02:01 +01:00
// Boost volume to 200% when downsampling from 6ch to 2ch
if ( channels . HasValue & & channels . Value < = 2 )
{
if ( state . AudioStream ! = null & & state . AudioStream . Channels . HasValue & & state . AudioStream . Channels . Value > 5 & & ! encodingOptions . DownMixAudioBoost . Equals ( 1 ) )
{
2017-04-15 21:45:33 +02:00
filters . Add ( "volume=" + encodingOptions . DownMixAudioBoost . ToString ( _usCulture ) ) ;
2017-02-02 17:02:01 +01:00
}
}
2017-04-04 07:20:07 +02:00
if ( state . SubtitleStream ! = null & & state . SubtitleStream . IsTextSubtitleStream & & state . SubtitleDeliveryMethod = = SubtitleDeliveryMethod . Encode & & ! state . CopyTimestamps )
2017-02-02 17:02:01 +01:00
{
var seconds = TimeSpan . FromTicks ( state . StartTimeTicks ? ? 0 ) . TotalSeconds ;
2017-04-15 21:45:33 +02:00
filters . Add ( string . Format ( "asetpts=PTS-{0}/TB" , Math . Round ( seconds ) . ToString ( _usCulture ) ) ) ;
2017-02-02 17:02:01 +01:00
}
2017-04-15 21:45:33 +02:00
if ( filters . Count > 0 )
{
return "-af \"" + string . Join ( "," , filters . ToArray ( ) ) + "\"" ;
}
2017-02-02 17:02:01 +01:00
2017-04-15 21:45:33 +02:00
return string . Empty ;
2017-02-02 17:02:01 +01: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>
/// <returns>System.Nullable{System.Int32}.</returns>
public int? GetNumAudioChannelsParam ( BaseEncodingJobOptions request , MediaStream audioStream , string outputAudioCodec )
{
var inputChannels = audioStream = = null
? null
: audioStream . Channels ;
if ( inputChannels < = 0 )
{
inputChannels = null ;
}
int? transcoderChannelLimit = null ;
var codec = outputAudioCodec ? ? string . Empty ;
if ( codec . IndexOf ( "wma" , StringComparison . OrdinalIgnoreCase ) ! = - 1 )
{
// wmav2 currently only supports two channel output
transcoderChannelLimit = 2 ;
}
else if ( codec . IndexOf ( "mp3" , StringComparison . OrdinalIgnoreCase ) ! = - 1 )
{
// libmp3lame currently only supports two channel output
transcoderChannelLimit = 2 ;
}
else
{
// If we don't have any media info then limit it to 6 to prevent encoding errors due to asking for too many channels
transcoderChannelLimit = 6 ;
}
var isTranscodingAudio = ! string . Equals ( codec , "copy" , StringComparison . OrdinalIgnoreCase ) ;
int? resultChannels = null ;
if ( isTranscodingAudio )
{
resultChannels = request . TranscodingMaxAudioChannels ;
}
resultChannels = resultChannels ? ? request . MaxAudioChannels ? ? request . AudioChannels ;
if ( inputChannels . HasValue )
{
resultChannels = resultChannels . HasValue
? Math . Min ( resultChannels . Value , inputChannels . Value )
: inputChannels . Value ;
}
if ( isTranscodingAudio & & transcoderChannelLimit . HasValue )
{
resultChannels = resultChannels . HasValue
? Math . Min ( resultChannels . Value , transcoderChannelLimit . Value )
: transcoderChannelLimit . Value ;
}
return resultChannels ? ? request . AudioChannels ;
}
/// <summary>
/// Enforces the resolution limit.
/// </summary>
/// <param name="state">The state.</param>
public void EnforceResolutionLimit ( EncodingJobInfo state )
{
var videoRequest = state . BaseRequest ;
// 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 ;
}
/// <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>
public string GetFastSeekCommandLineParameter ( BaseEncodingJobOptions request )
{
var time = request . StartTimeTicks ? ? 0 ;
if ( time > 0 )
{
return string . Format ( "-ss {0}" , _mediaEncoder . GetTimeParameter ( time ) ) ;
}
return string . Empty ;
}
/// <summary>
/// Gets the map args.
/// </summary>
/// <param name="state">The state.</param>
/// <returns>System.String.</returns>
public string GetMapArgs ( EncodingJobInfo state )
{
// 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 ;
}
// 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 )
{
return state . IsInputVideo ? "-sn" : string . Empty ;
}
var args = string . Empty ;
if ( state . VideoStream ! = null )
{
args + = string . Format ( "-map 0:{0}" , state . VideoStream . Index ) ;
}
else
{
// No known video stream
args + = "-vn" ;
}
if ( state . AudioStream ! = null )
{
args + = string . Format ( " -map 0:{0}" , state . AudioStream . Index ) ;
}
else
{
args + = " -map -0:a" ;
}
2017-04-04 07:20:07 +02:00
var subtitleMethod = state . SubtitleDeliveryMethod ;
2017-02-02 17:02:01 +01:00
if ( state . SubtitleStream = = null | | subtitleMethod = = SubtitleDeliveryMethod . Hls )
{
args + = " -map -0:s" ;
}
else if ( subtitleMethod = = SubtitleDeliveryMethod . Embed )
{
args + = string . Format ( " -map 0:{0}" , state . SubtitleStream . Index ) ;
}
else if ( state . SubtitleStream . IsExternal & & ! state . SubtitleStream . IsTextSubtitleStream )
{
args + = " -map 1:0 -sn" ;
}
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>
public 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 ( ) ;
if ( desiredIndex . HasValue )
{
var stream = streams . FirstOrDefault ( s = > s . Index = = desiredIndex . Value ) ;
if ( stream ! = null )
{
return stream ;
}
}
if ( returnFirstIfNoIndex & & type = = MediaStreamType . Audio )
{
return streams . FirstOrDefault ( i = > i . Channels . HasValue & & i . Channels . Value > 0 ) ? ?
streams . FirstOrDefault ( ) ;
}
// Just return the first one
return returnFirstIfNoIndex ? streams . FirstOrDefault ( ) : null ;
}
/// <summary>
/// Gets the internal graphical subtitle param.
/// </summary>
2017-09-17 08:42:23 +02:00
public string GetGraphicalSubtitleParam ( EncodingJobInfo state , EncodingOptions options , string outputVideoCodec )
2017-02-02 17:02:01 +01:00
{
var outputSizeParam = string . Empty ;
var request = state . BaseRequest ;
// Add resolution params, if specified
if ( request . Width . HasValue | | request . Height . HasValue | | request . MaxHeight . HasValue | | request . MaxWidth . HasValue )
{
2017-09-17 08:42:23 +02:00
outputSizeParam = GetOutputSizeParam ( state , options , outputVideoCodec ) . TrimEnd ( '"' ) ;
2017-02-02 17:02:01 +01:00
if ( string . Equals ( outputVideoCodec , "h264_vaapi" , StringComparison . OrdinalIgnoreCase ) )
{
outputSizeParam = "," + outputSizeParam . Substring ( outputSizeParam . IndexOf ( "format" , StringComparison . OrdinalIgnoreCase ) ) ;
}
else
{
outputSizeParam = "," + outputSizeParam . Substring ( outputSizeParam . IndexOf ( "scale" , StringComparison . OrdinalIgnoreCase ) ) ;
}
}
if ( string . Equals ( outputVideoCodec , "h264_vaapi" , StringComparison . OrdinalIgnoreCase ) & & outputSizeParam . Length = = 0 )
{
outputSizeParam = ",format=nv12|vaapi,hwupload" ;
}
var videoSizeParam = string . Empty ;
2017-04-15 21:45:33 +02:00
2017-02-02 17:02:01 +01:00
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 ) ) ;
}
var mapPrefix = state . SubtitleStream . IsExternal ?
1 :
0 ;
var subtitleStreamIndex = state . SubtitleStream . IsExternal
? 0
: state . SubtitleStream . Index ;
return string . Format ( " -filter_complex \"[{0}:{1}]{4}[sub] ; [0:{2}] [sub] overlay{3}\"" ,
mapPrefix . ToString ( _usCulture ) ,
subtitleStreamIndex . ToString ( _usCulture ) ,
state . VideoStream . Index . ToString ( _usCulture ) ,
outputSizeParam ,
videoSizeParam ) ;
}
/// <summary>
/// If we're going to put a fixed size on the command line, this will calculate it
/// </summary>
public string GetOutputSizeParam ( EncodingJobInfo state ,
2017-09-17 08:42:23 +02:00
EncodingOptions options ,
2017-02-02 17:02:01 +01:00
string outputVideoCodec ,
bool allowTimeStampCopy = true )
{
// http://sonnati.wordpress.com/2012/10/19/ffmpeg-the-swiss-army-knife-of-internet-streaming-part-vi/
var request = state . BaseRequest ;
var filters = new List < string > ( ) ;
if ( string . Equals ( outputVideoCodec , "h264_vaapi" , StringComparison . OrdinalIgnoreCase ) )
{
filters . Add ( "format=nv12|vaapi" ) ;
filters . Add ( "hwupload" ) ;
}
2017-05-11 16:54:41 +02:00
2017-09-27 16:52:01 +02:00
if ( state . DeInterlace ( "h264" , true ) & & ! string . Equals ( outputVideoCodec , "h264_vaapi" , StringComparison . OrdinalIgnoreCase ) )
2017-02-02 17:02:01 +01:00
{
2017-09-25 21:15:01 +02:00
// If it is already 60fps then it will create an output framerate that is much too high for roku and others to handle
if ( string . Equals ( options . DeinterlaceMethod , "bobandweave" , StringComparison . OrdinalIgnoreCase ) & & ( state . VideoStream . RealFrameRate ? ? 60 ) < = 30 )
2017-09-17 08:42:23 +02:00
{
filters . Add ( "yadif=1:-1:0" ) ;
}
else
{
filters . Add ( "yadif=0:-1:0" ) ;
}
2017-02-02 17:02:01 +01:00
}
if ( string . Equals ( outputVideoCodec , "h264_vaapi" , StringComparison . OrdinalIgnoreCase ) )
{
// Work around vaapi's reduced scaling features
var scaler = "scale_vaapi" ;
// Given the input dimensions (inputWidth, inputHeight), determine the output dimensions
// (outputWidth, outputHeight). The user may request precise output dimensions or maximum
// output dimensions. Output dimensions are guaranteed to be even.
decimal inputWidth = Convert . ToDecimal ( state . VideoStream . Width ) ;
decimal inputHeight = Convert . ToDecimal ( state . VideoStream . Height ) ;
decimal outputWidth = request . Width . HasValue ? Convert . ToDecimal ( request . Width . Value ) : inputWidth ;
decimal outputHeight = request . Height . HasValue ? Convert . ToDecimal ( request . Height . Value ) : inputHeight ;
decimal maximumWidth = request . MaxWidth . HasValue ? Convert . ToDecimal ( request . MaxWidth . Value ) : outputWidth ;
decimal maximumHeight = request . MaxHeight . HasValue ? Convert . ToDecimal ( request . MaxHeight . Value ) : outputHeight ;
if ( outputWidth > maximumWidth | | outputHeight > maximumHeight )
{
var scale = Math . Min ( maximumWidth / outputWidth , maximumHeight / outputHeight ) ;
outputWidth = Math . Min ( maximumWidth , Math . Truncate ( outputWidth * scale ) ) ;
outputHeight = Math . Min ( maximumHeight , Math . Truncate ( outputHeight * scale ) ) ;
}
outputWidth = 2 * Math . Truncate ( outputWidth / 2 ) ;
outputHeight = 2 * Math . Truncate ( outputHeight / 2 ) ;
if ( outputWidth ! = inputWidth | | outputHeight ! = inputHeight )
{
filters . Add ( string . Format ( "{0}=w={1}:h={2}" , scaler , outputWidth . ToString ( _usCulture ) , outputHeight . ToString ( _usCulture ) ) ) ;
}
}
else
{
2017-09-17 07:24:39 +02:00
var isExynosV4L2 = string . Equals ( outputVideoCodec , "h264_v4l2m2m" , StringComparison . OrdinalIgnoreCase ) ;
2017-02-02 17:02:01 +01:00
// If fixed dimensions were supplied
if ( request . Width . HasValue & & request . Height . HasValue )
{
var widthParam = request . Width . Value . ToString ( _usCulture ) ;
var heightParam = request . Height . Value . ToString ( _usCulture ) ;
2017-09-17 07:24:39 +02:00
if ( isExynosV4L2 )
{
filters . Add ( string . Format ( "scale=trunc({0}/64)*64:trunc({1}/2)*2" , widthParam , heightParam ) ) ;
}
else
{
filters . Add ( string . Format ( "scale=trunc({0}/2)*2:trunc({1}/2)*2" , widthParam , heightParam ) ) ;
}
2017-02-02 17:02:01 +01: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
else if ( request . MaxWidth . HasValue & & request . MaxHeight . HasValue )
{
var maxWidthParam = request . MaxWidth . Value . ToString ( _usCulture ) ;
var maxHeightParam = request . MaxHeight . Value . ToString ( _usCulture ) ;
2017-09-17 07:24:39 +02:00
if ( isExynosV4L2 )
{
filters . Add ( string . Format ( "scale=trunc(min(max(iw\\,ih*dar)\\,min({0}\\,{1}*dar))/64)*64:trunc(min(max(iw/dar\\,ih)\\,min({0}/dar\\,{1}))/2)*2" , maxWidthParam , maxHeightParam ) ) ;
}
else
{
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 ) ) ;
}
2017-02-02 17:02:01 +01:00
}
// If a fixed width was requested
else if ( request . Width . HasValue )
{
var widthParam = request . Width . Value . ToString ( _usCulture ) ;
filters . Add ( string . Format ( "scale={0}:trunc(ow/a/2)*2" , widthParam ) ) ;
}
// If a fixed height was requested
else if ( request . Height . HasValue )
{
var heightParam = request . Height . Value . ToString ( _usCulture ) ;
2017-09-17 07:24:39 +02:00
if ( isExynosV4L2 )
{
filters . Add ( string . Format ( "scale=trunc(oh*a/64)*64:{0}" , heightParam ) ) ;
}
else
{
filters . Add ( string . Format ( "scale=trunc(oh*a/2)*2:{0}" , heightParam ) ) ;
}
2017-02-02 17:02:01 +01:00
}
// If a max width was requested
else if ( request . MaxWidth . HasValue )
{
var maxWidthParam = request . MaxWidth . Value . ToString ( _usCulture ) ;
2017-09-17 07:24:39 +02:00
if ( isExynosV4L2 )
{
filters . Add ( string . Format ( "scale=trunc(min(max(iw\\,ih*dar)\\,{0})/64)*64:trunc(ow/dar/2)*2" , maxWidthParam ) ) ;
}
else
{
filters . Add ( string . Format ( "scale=trunc(min(max(iw\\,ih*dar)\\,{0})/2)*2:trunc(ow/dar/2)*2" , maxWidthParam ) ) ;
}
2017-02-02 17:02:01 +01:00
}
// If a max height was requested
else if ( request . MaxHeight . HasValue )
{
var maxHeightParam = request . MaxHeight . Value . ToString ( _usCulture ) ;
2017-09-17 07:24:39 +02:00
if ( isExynosV4L2 )
{
filters . Add ( string . Format ( "scale=trunc(oh*a/64)*64:min(max(iw/dar\\,ih)\\,{0})" , maxHeightParam ) ) ;
}
else
{
filters . Add ( string . Format ( "scale=trunc(oh*a/2)*2:min(max(iw/dar\\,ih)\\,{0})" , maxHeightParam ) ) ;
}
2017-02-02 17:02:01 +01:00
}
}
var output = string . Empty ;
2017-04-04 07:20:07 +02:00
if ( state . SubtitleStream ! = null & & state . SubtitleStream . IsTextSubtitleStream & & state . SubtitleDeliveryMethod = = SubtitleDeliveryMethod . Encode )
2017-02-02 17:02:01 +01:00
{
var subParam = GetTextSubtitleParam ( state ) ;
filters . Add ( subParam ) ;
if ( allowTimeStampCopy )
{
output + = " -copyts" ;
}
}
2017-08-23 20:44:40 +02:00
if ( state . EnableMpDecimate )
{
filters . Add ( "mpdecimate,setpts=N/FRAME_RATE/TB" ) ;
}
2017-02-02 17:02:01 +01:00
if ( filters . Count > 0 )
{
output + = string . Format ( " -vf \"{0}\"" , string . Join ( "," , filters . ToArray ( ) ) ) ;
}
return output ;
}
/// <summary>
/// Gets the number of threads.
/// </summary>
/// <returns>System.Int32.</returns>
public int GetNumberOfThreads ( EncodingJobInfo state , EncodingOptions encodingOptions , bool isWebm )
{
2017-09-29 08:13:05 +02:00
if ( isWebm )
{
// Recommended per docs
return Math . Max ( Environment . ProcessorCount - 1 , 2 ) ;
}
var threads = state . BaseRequest . CpuCoreLimit ? ? encodingOptions . EncodingThreadCount ;
2017-02-02 17:02:01 +01:00
2017-09-29 08:13:05 +02:00
// Automatic
if ( threads < = 0 | | threads > = Environment . ProcessorCount )
2017-02-02 17:02:01 +01:00
{
2017-09-29 08:13:05 +02:00
return 0 ;
2017-02-02 17:02:01 +01:00
}
return threads ;
}
public void TryStreamCopy ( EncodingJobInfo state )
{
if ( state . VideoStream ! = null & & CanStreamCopyVideo ( state , state . VideoStream ) )
{
state . OutputVideoCodec = "copy" ;
}
else
{
var user = state . User ;
// If the user doesn't have access to transcoding, then force stream copy, regardless of whether it will be compatible or not
if ( user ! = null & & ! user . Policy . EnableVideoPlaybackTranscoding )
{
state . OutputVideoCodec = "copy" ;
}
}
if ( state . AudioStream ! = null & & CanStreamCopyAudio ( state , state . AudioStream , state . SupportedAudioCodecs ) )
{
state . OutputAudioCodec = "copy" ;
}
else
{
var user = state . User ;
// If the user doesn't have access to transcoding, then force stream copy, regardless of whether it will be compatible or not
if ( user ! = null & & ! user . Policy . EnableAudioPlaybackTranscoding )
{
state . OutputAudioCodec = "copy" ;
}
}
}
2017-03-05 16:38:36 +01:00
public static string GetProbeSizeArgument ( int numInputFiles )
{
return numInputFiles > 1 ? "-probesize 1G" : "" ;
}
public static string GetAnalyzeDurationArgument ( int numInputFiles )
{
return numInputFiles > 1 ? "-analyzeduration 200M" : "" ;
}
2017-02-02 17:02:01 +01:00
public string GetInputModifier ( EncodingJobInfo state , EncodingOptions encodingOptions )
{
var inputModifier = string . Empty ;
2017-08-19 21:43:35 +02:00
var numInputFiles = state . PlayableStreamFileNames . Length > 0 ? state . PlayableStreamFileNames . Length : 1 ;
2017-03-05 16:38:36 +01:00
var probeSizeArgument = GetProbeSizeArgument ( numInputFiles ) ;
string analyzeDurationArgument ;
if ( state . MediaSource . AnalyzeDurationMs . HasValue )
{
analyzeDurationArgument = "-analyzeduration " + ( state . MediaSource . AnalyzeDurationMs . Value * 1000 ) . ToString ( CultureInfo . InvariantCulture ) ;
}
else
{
analyzeDurationArgument = GetAnalyzeDurationArgument ( numInputFiles ) ;
}
if ( ! string . IsNullOrWhiteSpace ( probeSizeArgument ) )
{
inputModifier + = " " + probeSizeArgument ;
}
if ( ! string . IsNullOrWhiteSpace ( analyzeDurationArgument ) )
{
inputModifier + = " " + analyzeDurationArgument ;
}
2017-02-02 17:02:01 +01:00
inputModifier = inputModifier . Trim ( ) ;
var userAgentParam = GetUserAgentParam ( state ) ;
if ( ! string . IsNullOrWhiteSpace ( userAgentParam ) )
{
inputModifier + = " " + userAgentParam ;
}
inputModifier = inputModifier . Trim ( ) ;
inputModifier + = " " + GetFastSeekCommandLineParameter ( state . BaseRequest ) ;
inputModifier = inputModifier . Trim ( ) ;
2017-09-10 20:35:23 +02:00
2017-07-28 18:15:31 +02:00
if ( state . InputProtocol = = MediaProtocol . Rtsp )
{
inputModifier + = " -rtsp_transport tcp" ;
}
2017-02-02 17:02:01 +01:00
if ( ! string . IsNullOrEmpty ( state . InputAudioSync ) )
{
inputModifier + = " -async " + state . InputAudioSync ;
}
if ( ! string . IsNullOrEmpty ( state . InputVideoSync ) )
{
inputModifier + = " -vsync " + state . InputVideoSync ;
}
2017-07-28 18:15:31 +02:00
if ( state . ReadInputAtNativeFramerate & & state . InputProtocol ! = MediaProtocol . Rtsp )
2017-02-02 17:02:01 +01:00
{
inputModifier + = " -re" ;
}
2017-04-30 22:03:28 +02:00
var flags = new List < string > ( ) ;
2017-05-11 16:54:41 +02:00
if ( state . IgnoreInputDts )
2017-04-30 22:03:28 +02:00
{
flags . Add ( "+igndts" ) ;
}
2017-05-11 16:54:41 +02:00
if ( state . IgnoreInputIndex )
2017-04-30 22:03:28 +02:00
{
flags . Add ( "+ignidx" ) ;
}
2017-05-11 16:54:41 +02:00
if ( state . GenPtsInput )
{
flags . Add ( "+genpts" ) ;
}
if ( state . DiscardCorruptFramesInput )
{
flags . Add ( "+discardcorrupt" ) ;
}
if ( state . EnableFastSeekInput )
{
flags . Add ( "+fastseek" ) ;
}
2017-04-30 22:03:28 +02:00
if ( flags . Count > 0 )
{
inputModifier + = " -fflags " + string . Join ( "" , flags . ToArray ( ) ) ;
}
2017-02-02 17:02:01 +01:00
var videoDecoder = GetVideoDecoder ( state , encodingOptions ) ;
if ( ! string . IsNullOrWhiteSpace ( videoDecoder ) )
{
inputModifier + = " " + videoDecoder ;
}
if ( state . IsVideoRequest )
{
2017-04-09 23:38:59 +02:00
var outputVideoCodec = GetVideoEncoder ( state , encodingOptions ) ;
2017-02-02 17:02:01 +01:00
// Important: If this is ever re-enabled, make sure not to use it with wtv because it breaks seeking
2017-04-15 21:45:33 +02:00
if ( ! string . Equals ( state . InputContainer , "wtv" , StringComparison . OrdinalIgnoreCase ) & &
2017-04-09 23:38:59 +02:00
state . TranscodingType ! = TranscodingJobType . Progressive & &
state . EnableBreakOnNonKeyFrames ( outputVideoCodec ) )
2017-02-02 17:02:01 +01:00
{
2017-04-09 23:38:59 +02:00
inputModifier + = " -noaccurate_seek" ;
2017-02-02 17:02:01 +01:00
}
2017-03-01 21:29:42 +01:00
if ( ! string . IsNullOrWhiteSpace ( state . InputContainer ) & & state . VideoType = = VideoType . VideoFile & & string . IsNullOrWhiteSpace ( encodingOptions . HardwareAccelerationType ) )
2017-02-10 01:42:57 +01:00
{
var inputFormat = GetInputFormat ( state . InputContainer ) ;
if ( ! string . IsNullOrWhiteSpace ( inputFormat ) )
{
inputModifier + = " -f " + inputFormat ;
}
}
2017-02-02 17:02:01 +01:00
}
2017-04-13 20:57:57 +02:00
if ( state . MediaSource . RequiresLooping )
{
inputModifier + = " -stream_loop -1" ;
}
2017-02-02 17:02:01 +01:00
return inputModifier ;
}
public void AttachMediaSourceInfo ( EncodingJobInfo state ,
MediaSourceInfo mediaSource ,
string requestedUrl )
{
2017-03-26 06:20:50 +02:00
if ( state = = null )
{
throw new ArgumentNullException ( "state" ) ;
}
if ( mediaSource = = null )
{
throw new ArgumentNullException ( "mediaSource" ) ;
}
2017-02-02 17:02:01 +01:00
state . MediaPath = mediaSource . Path ;
state . InputProtocol = mediaSource . Protocol ;
state . InputContainer = mediaSource . Container ;
state . RunTimeTicks = mediaSource . RunTimeTicks ;
state . RemoteHttpHeaders = mediaSource . RequiredHttpHeaders ;
2017-08-05 21:02:33 +02:00
state . IsoType = mediaSource . IsoType ;
2017-02-02 17:02:01 +01:00
if ( mediaSource . VideoType . HasValue )
{
state . VideoType = mediaSource . VideoType . Value ;
2017-08-05 21:02:33 +02:00
if ( mediaSource . VideoType . Value = = VideoType . BluRay | | mediaSource . VideoType . Value = = VideoType . Dvd )
{
2017-08-22 07:41:20 +02:00
state . PlayableStreamFileNames = Video . QueryPlayableStreamFiles ( state . MediaPath , mediaSource . VideoType . Value ) . Select ( Path . GetFileName ) . ToArray ( ) ;
2017-08-05 21:02:33 +02:00
}
else if ( mediaSource . VideoType . Value = = VideoType . Iso & & state . IsoType = = IsoType . BluRay )
{
2017-08-22 07:41:20 +02:00
state . PlayableStreamFileNames = Video . QueryPlayableStreamFiles ( state . MediaPath , VideoType . BluRay ) . Select ( Path . GetFileName ) . ToArray ( ) ;
2017-08-05 21:02:33 +02:00
}
else if ( mediaSource . VideoType . Value = = VideoType . Iso & & state . IsoType = = IsoType . Dvd )
{
2017-08-22 07:41:20 +02:00
state . PlayableStreamFileNames = Video . QueryPlayableStreamFiles ( state . MediaPath , VideoType . Dvd ) . Select ( Path . GetFileName ) . ToArray ( ) ;
2017-08-05 21:02:33 +02:00
}
else
{
2017-09-10 20:35:23 +02:00
state . PlayableStreamFileNames = new string [ ] { } ;
2017-08-05 21:02:33 +02:00
}
}
else
{
2017-08-19 21:43:35 +02:00
state . PlayableStreamFileNames = new string [ ] { } ;
2017-08-05 21:02:33 +02:00
}
2017-02-02 17:02:01 +01:00
if ( mediaSource . Timestamp . HasValue )
{
state . InputTimestamp = mediaSource . Timestamp . Value ;
}
state . InputProtocol = mediaSource . Protocol ;
state . MediaPath = mediaSource . Path ;
state . RunTimeTicks = mediaSource . RunTimeTicks ;
state . RemoteHttpHeaders = mediaSource . RequiredHttpHeaders ;
state . ReadInputAtNativeFramerate = mediaSource . ReadAtNativeFramerate ;
if ( state . ReadInputAtNativeFramerate | |
mediaSource . Protocol = = MediaProtocol . File & & string . Equals ( mediaSource . Container , "wtv" , StringComparison . OrdinalIgnoreCase ) )
{
state . InputVideoSync = "-1" ;
state . InputAudioSync = "1" ;
}
2017-08-04 22:29:34 +02:00
if ( string . Equals ( mediaSource . Container , "wma" , StringComparison . OrdinalIgnoreCase ) | |
string . Equals ( mediaSource . Container , "asf" , StringComparison . OrdinalIgnoreCase ) )
2017-02-02 17:02:01 +01:00
{
// Seeing some stuttering when transcoding wma to audio-only HLS
state . InputAudioSync = "1" ;
}
var mediaStreams = mediaSource . MediaStreams ;
if ( state . IsVideoRequest )
{
var videoRequest = state . BaseRequest ;
if ( string . IsNullOrEmpty ( videoRequest . VideoCodec ) )
{
if ( string . IsNullOrWhiteSpace ( requestedUrl ) )
{
requestedUrl = "test." + videoRequest . OutputContainer ;
}
videoRequest . VideoCodec = InferVideoCodec ( requestedUrl ) ;
}
state . VideoStream = GetMediaStream ( mediaStreams , videoRequest . VideoStreamIndex , MediaStreamType . Video ) ;
state . SubtitleStream = GetMediaStream ( mediaStreams , videoRequest . SubtitleStreamIndex , MediaStreamType . Subtitle , false ) ;
state . SubtitleDeliveryMethod = videoRequest . SubtitleMethod ;
state . AudioStream = GetMediaStream ( mediaStreams , videoRequest . AudioStreamIndex , MediaStreamType . Audio ) ;
if ( state . SubtitleStream ! = null & & ! state . SubtitleStream . IsExternal )
{
state . InternalSubtitleStreamOffset = mediaStreams . Where ( i = > i . Type = = MediaStreamType . Subtitle & & ! i . IsExternal ) . ToList ( ) . IndexOf ( state . SubtitleStream ) ;
}
EnforceResolutionLimit ( state ) ;
2017-04-04 07:20:07 +02:00
NormalizeSubtitleEmbed ( state ) ;
2017-02-02 17:02:01 +01:00
}
else
{
state . AudioStream = GetMediaStream ( mediaStreams , null , MediaStreamType . Audio , true ) ;
}
state . MediaSource = mediaSource ;
}
2017-04-04 07:20:07 +02:00
private void NormalizeSubtitleEmbed ( EncodingJobInfo state )
{
if ( state . SubtitleStream = = null | | state . SubtitleDeliveryMethod ! = SubtitleDeliveryMethod . Embed )
{
2017-04-15 21:45:33 +02:00
return ;
2017-04-04 07:20:07 +02:00
}
// This is tricky to remux in, after converting to dvdsub it's not positioned correctly
// Therefore, let's just burn it in
if ( string . Equals ( state . SubtitleStream . Codec , "DVBSUB" , StringComparison . OrdinalIgnoreCase ) )
{
state . SubtitleDeliveryMethod = SubtitleDeliveryMethod . Encode ;
}
}
2017-02-02 17:02:01 +01:00
/// <summary>
/// Gets the name of the output video codec
/// </summary>
protected string GetVideoDecoder ( EncodingJobInfo state , EncodingOptions encodingOptions )
{
if ( string . Equals ( state . OutputVideoCodec , "copy" , StringComparison . OrdinalIgnoreCase ) )
{
return null ;
}
2017-08-01 21:43:39 +02:00
return GetVideoDecoder ( state . MediaSource . VideoType ? ? VideoType . VideoFile , state . VideoStream , encodingOptions ) ;
}
public string GetVideoDecoder ( VideoType videoType , MediaStream videoStream , EncodingOptions encodingOptions )
{
2017-02-02 17:02:01 +01:00
// Only use alternative encoders for video files.
// When using concat with folder rips, if the mfx session fails to initialize, ffmpeg will be stuck retrying and will not exit gracefully
// Since transcoding of folder rips is expiremental anyway, it's not worth adding additional variables such as this.
2017-08-01 21:43:39 +02:00
if ( videoType ! = VideoType . VideoFile )
2017-02-02 17:02:01 +01:00
{
return null ;
}
2017-08-01 21:43:39 +02:00
if ( videoStream ! = null & &
! string . IsNullOrWhiteSpace ( videoStream . Codec ) & &
2017-08-12 21:09:13 +02:00
! string . IsNullOrWhiteSpace ( encodingOptions . HardwareAccelerationType ) )
2017-02-02 17:02:01 +01:00
{
if ( string . Equals ( encodingOptions . HardwareAccelerationType , "qsv" , StringComparison . OrdinalIgnoreCase ) )
{
2017-08-01 21:43:39 +02:00
switch ( videoStream . Codec . ToLower ( ) )
2017-02-02 17:02:01 +01:00
{
case "avc" :
case "h264" :
2017-08-12 21:09:13 +02:00
if ( _mediaEncoder . SupportsDecoder ( "h264_qsv" ) & & encodingOptions . HardwareDecodingCodecs . Contains ( "h264" , StringComparer . OrdinalIgnoreCase ) )
2017-02-02 17:02:01 +01:00
{
2017-03-10 19:33:17 +01:00
// qsv decoder does not support 10-bit input
2017-08-01 21:43:39 +02:00
if ( ( videoStream . BitDepth ? ? 8 ) > 8 )
2017-03-10 19:33:17 +01:00
{
return null ;
}
2017-02-02 17:02:01 +01:00
return "-c:v h264_qsv " ;
}
break ;
2017-08-12 21:09:13 +02:00
case "hevc" :
case "h265" :
if ( _mediaEncoder . SupportsDecoder ( "hevc_qsv" ) & & encodingOptions . HardwareDecodingCodecs . Contains ( "hevc" , StringComparer . OrdinalIgnoreCase ) )
{
return "-c:v hevc_qsv " ;
}
break ;
2017-02-02 17:02:01 +01:00
case "mpeg2video" :
2017-08-12 21:09:13 +02:00
if ( _mediaEncoder . SupportsDecoder ( "mpeg2_qsv" ) & & encodingOptions . HardwareDecodingCodecs . Contains ( "mpeg2video" , StringComparer . OrdinalIgnoreCase ) )
2017-02-02 17:02:01 +01:00
{
return "-c:v mpeg2_qsv " ;
}
break ;
case "vc1" :
2017-08-12 21:09:13 +02:00
if ( _mediaEncoder . SupportsDecoder ( "vc1_qsv" ) & & encodingOptions . HardwareDecodingCodecs . Contains ( "vc1" , StringComparer . OrdinalIgnoreCase ) )
2017-02-02 17:02:01 +01:00
{
return "-c:v vc1_qsv " ;
}
2017-06-10 20:24:53 +02:00
break ;
}
}
else if ( string . Equals ( encodingOptions . HardwareAccelerationType , "nvenc" , StringComparison . OrdinalIgnoreCase ) )
{
2017-08-01 21:43:39 +02:00
switch ( videoStream . Codec . ToLower ( ) )
2017-06-10 20:24:53 +02:00
{
case "avc" :
case "h264" :
2017-08-12 21:09:13 +02:00
if ( _mediaEncoder . SupportsDecoder ( "h264_cuvid" ) & & encodingOptions . HardwareDecodingCodecs . Contains ( "h264" , StringComparer . OrdinalIgnoreCase ) )
2017-06-10 20:24:53 +02:00
{
return "-c:v h264_cuvid " ;
}
2017-06-12 08:11:19 +02:00
break ;
case "hevc" :
case "h265" :
2017-08-12 21:09:13 +02:00
if ( _mediaEncoder . SupportsDecoder ( "hevc_cuvid" ) & & encodingOptions . HardwareDecodingCodecs . Contains ( "hevc" , StringComparer . OrdinalIgnoreCase ) )
2017-06-12 08:11:19 +02:00
{
return "-c:v hevc_cuvid " ;
}
2017-08-13 20:05:46 +02:00
break ;
case "mpeg2video" :
if ( _mediaEncoder . SupportsDecoder ( "mpeg2_cuvid" ) & & encodingOptions . HardwareDecodingCodecs . Contains ( "mpeg2video" , StringComparer . OrdinalIgnoreCase ) )
{
return "-c:v mpeg2_cuvid " ;
}
break ;
case "vc1" :
if ( _mediaEncoder . SupportsDecoder ( "vc1_cuvid" ) & & encodingOptions . HardwareDecodingCodecs . Contains ( "vc1" , StringComparer . OrdinalIgnoreCase ) )
{
return "-c:v vc1_cuvid " ;
}
break ;
case "mpeg4" :
if ( _mediaEncoder . SupportsDecoder ( "mpeg4_cuvid" ) & & encodingOptions . HardwareDecodingCodecs . Contains ( "mpeg4" , StringComparer . OrdinalIgnoreCase ) )
{
return "-c:v mpeg4_cuvid " ;
}
2017-09-15 19:57:42 +02:00
break ;
}
}
else if ( string . Equals ( encodingOptions . HardwareAccelerationType , "omx" , StringComparison . OrdinalIgnoreCase ) )
{
switch ( videoStream . Codec . ToLower ( ) )
{
case "avc" :
case "h264" :
2017-09-17 07:24:39 +02:00
if ( _mediaEncoder . SupportsDecoder ( "h264_mmal" ) & & encodingOptions . HardwareDecodingCodecs . Contains ( "h264" , StringComparer . OrdinalIgnoreCase ) )
2017-09-15 19:57:42 +02:00
{
2017-09-17 07:24:39 +02:00
return "-c:v h264_mmal" ;
2017-09-15 19:57:42 +02:00
}
2017-02-02 17:02:01 +01:00
break ;
}
}
}
// leave blank so ffmpeg will decide
return null ;
}
2017-03-19 07:10:11 +01:00
public string GetSubtitleEmbedArguments ( EncodingJobInfo state )
{
if ( state . SubtitleStream = = null | | state . SubtitleDeliveryMethod ! = SubtitleDeliveryMethod . Embed )
{
return string . Empty ;
}
var format = state . SupportedSubtitleCodecs . FirstOrDefault ( ) ;
string codec ;
if ( string . IsNullOrWhiteSpace ( format ) | | string . Equals ( format , state . SubtitleStream . Codec , StringComparison . OrdinalIgnoreCase ) )
{
codec = "copy" ;
}
else
{
codec = format ;
}
var args = " -codec:s:0 " + codec ;
args + = " -disposition:s:0 default" ;
return args ;
}
2017-03-19 19:59:05 +01:00
public string GetProgressiveVideoFullCommandLine ( EncodingJobInfo state , EncodingOptions encodingOptions , string outputPath , string defaultH264Preset )
{
// Get the output codec name
var videoCodec = GetVideoEncoder ( state , encodingOptions ) ;
var format = string . Empty ;
var keyFrame = string . Empty ;
if ( string . Equals ( Path . GetExtension ( outputPath ) , ".mp4" , StringComparison . OrdinalIgnoreCase ) & &
state . BaseRequest . Context = = EncodingContext . Streaming )
{
// Comparison: https://github.com/jansmolders86/mediacenterjs/blob/master/lib/transcoding/desktop.js
format = " -f mp4 -movflags frag_keyframe+empty_moov" ;
}
var threads = GetNumberOfThreads ( state , encodingOptions , string . Equals ( videoCodec , "libvpx" , StringComparison . OrdinalIgnoreCase ) ) ;
var inputModifier = GetInputModifier ( state , encodingOptions ) ;
return string . Format ( "{0} {1}{2} {3} {4} -map_metadata -1 -map_chapters -1 -threads {5} {6}{7}{8} -y \"{9}\"" ,
inputModifier ,
GetInputArgument ( state , encodingOptions ) ,
keyFrame ,
GetMapArgs ( state ) ,
GetProgressiveVideoArguments ( state , encodingOptions , videoCodec , defaultH264Preset ) ,
threads ,
GetProgressiveVideoAudioArguments ( state , encodingOptions ) ,
GetSubtitleEmbedArguments ( state ) ,
format ,
outputPath
) . Trim ( ) ;
}
2017-05-11 16:54:41 +02:00
public string GetOutputFFlags ( EncodingJobInfo state )
{
var flags = new List < string > ( ) ;
if ( state . GenPtsOutput )
{
flags . Add ( "+genpts" ) ;
}
if ( flags . Count > 0 )
{
return " -fflags " + string . Join ( "" , flags . ToArray ( ) ) ;
}
return string . Empty ;
}
2017-03-19 19:59:05 +01:00
public string GetProgressiveVideoArguments ( EncodingJobInfo state , EncodingOptions encodingOptions , string videoCodec , string defaultH264Preset )
{
var args = "-codec:v:0 " + videoCodec ;
if ( state . EnableMpegtsM2TsMode )
{
args + = " -mpegts_m2ts_mode 1" ;
}
if ( string . Equals ( videoCodec , "copy" , StringComparison . OrdinalIgnoreCase ) )
{
2017-04-09 23:38:59 +02:00
if ( state . VideoStream ! = null & & IsH264 ( state . VideoStream ) & &
string . Equals ( state . OutputContainer , "ts" , StringComparison . OrdinalIgnoreCase ) & &
! string . Equals ( state . VideoStream . NalLengthSize , "0" , StringComparison . OrdinalIgnoreCase ) )
2017-03-19 19:59:05 +01:00
{
args + = " -bsf:v h264_mp4toannexb" ;
}
if ( state . RunTimeTicks . HasValue & & state . BaseRequest . CopyTimestamps )
{
args + = " -copyts -avoid_negative_ts disabled -start_at_zero" ;
}
if ( ! state . RunTimeTicks . HasValue )
{
args + = " -flags -global_header -fflags +genpts" ;
}
}
2017-04-09 23:38:59 +02:00
else
{
var keyFrameArg = string . Format ( " -force_key_frames \"expr:gte(t,n_forced*{0})\"" ,
5. ToString ( _usCulture ) ) ;
2017-03-19 19:59:05 +01:00
2017-04-09 23:38:59 +02:00
args + = keyFrameArg ;
2017-03-19 19:59:05 +01:00
2017-04-09 23:38:59 +02:00
var hasGraphicalSubs = state . SubtitleStream ! = null & & ! state . SubtitleStream . IsTextSubtitleStream & & state . SubtitleDeliveryMethod = = SubtitleDeliveryMethod . Encode ;
2017-03-19 19:59:05 +01:00
2017-04-09 23:38:59 +02:00
var hasCopyTs = false ;
// Add resolution params, if specified
if ( ! hasGraphicalSubs )
{
2017-09-17 08:42:23 +02:00
var outputSizeParam = GetOutputSizeParam ( state , encodingOptions , videoCodec ) ;
2017-04-09 23:38:59 +02:00
args + = outputSizeParam ;
hasCopyTs = outputSizeParam . IndexOf ( "copyts" , StringComparison . OrdinalIgnoreCase ) ! = - 1 ;
}
2017-03-19 19:59:05 +01:00
2017-04-09 23:38:59 +02:00
if ( state . RunTimeTicks . HasValue & & state . BaseRequest . CopyTimestamps )
2017-03-19 19:59:05 +01:00
{
2017-04-09 23:38:59 +02:00
if ( ! hasCopyTs )
{
args + = " -copyts" ;
}
args + = " -avoid_negative_ts disabled -start_at_zero" ;
2017-03-19 19:59:05 +01:00
}
2017-04-09 23:38:59 +02:00
var qualityParam = GetVideoQualityParam ( state , videoCodec , encodingOptions , defaultH264Preset ) ;
2017-03-19 19:59:05 +01:00
2017-04-09 23:38:59 +02:00
if ( ! string . IsNullOrEmpty ( qualityParam ) )
{
args + = " " + qualityParam . Trim ( ) ;
}
2017-03-19 19:59:05 +01:00
2017-04-09 23:38:59 +02:00
// This is for internal graphical subs
if ( hasGraphicalSubs )
{
2017-09-17 08:42:23 +02:00
args + = GetGraphicalSubtitleParam ( state , encodingOptions , videoCodec ) ;
2017-04-09 23:38:59 +02:00
}
if ( ! state . RunTimeTicks . HasValue )
{
args + = " -flags -global_header" ;
}
2017-03-19 19:59:05 +01:00
}
2017-04-09 23:38:59 +02:00
if ( ! string . IsNullOrEmpty ( state . OutputVideoSync ) )
2017-03-19 19:59:05 +01:00
{
2017-04-09 23:38:59 +02:00
args + = " -vsync " + state . OutputVideoSync ;
2017-03-19 19:59:05 +01:00
}
2017-05-11 16:54:41 +02:00
args + = GetOutputFFlags ( state ) ;
2017-03-19 19:59:05 +01:00
return args ;
}
2017-03-19 07:10:11 +01:00
public string GetProgressiveVideoAudioArguments ( EncodingJobInfo state , EncodingOptions encodingOptions )
{
// If the video doesn't have an audio stream, return a default.
if ( state . AudioStream = = null & & state . VideoStream ! = null )
{
return string . Empty ;
}
// Get the output codec name
var codec = GetAudioEncoder ( state ) ;
var args = "-codec:a:0 " + codec ;
if ( string . Equals ( codec , "copy" , StringComparison . OrdinalIgnoreCase ) )
{
return args ;
}
// Add the number of audio channels
var channels = state . OutputAudioChannels ;
if ( channels . HasValue )
{
args + = " -ac " + channels . Value ;
}
var bitrate = state . OutputAudioBitrate ;
if ( bitrate . HasValue )
{
args + = " -ab " + bitrate . Value . ToString ( _usCulture ) ;
}
2017-04-15 21:45:33 +02:00
if ( state . OutputAudioSampleRate . HasValue )
{
args + = " -ar " + state . OutputAudioSampleRate . Value . ToString ( _usCulture ) ;
}
2017-03-19 07:10:11 +01:00
args + = " " + GetAudioFilterParam ( state , encodingOptions , false ) ;
return args ;
}
2017-04-27 20:13:16 +02:00
public string GetProgressiveAudioFullCommandLine ( EncodingJobInfo state , EncodingOptions encodingOptions , string outputPath )
{
var audioTranscodeParams = new List < string > ( ) ;
var bitrate = state . OutputAudioBitrate ;
if ( bitrate . HasValue )
{
audioTranscodeParams . Add ( "-ab " + bitrate . Value . ToString ( _usCulture ) ) ;
}
if ( state . OutputAudioChannels . HasValue )
{
audioTranscodeParams . Add ( "-ac " + state . OutputAudioChannels . Value . ToString ( _usCulture ) ) ;
}
// opus will fail on 44100
if ( ! string . Equals ( state . OutputAudioCodec , "opus" , StringComparison . OrdinalIgnoreCase ) )
{
if ( state . OutputAudioSampleRate . HasValue )
{
audioTranscodeParams . Add ( "-ar " + state . OutputAudioSampleRate . Value . ToString ( _usCulture ) ) ;
}
}
var albumCoverInput = string . Empty ;
var mapArgs = string . Empty ;
var metadata = string . Empty ;
var vn = string . Empty ;
var hasArt = ! string . IsNullOrWhiteSpace ( state . AlbumCoverPath ) ;
2017-07-31 21:08:54 +02:00
hasArt = false ;
2017-04-27 20:13:16 +02:00
if ( hasArt )
{
albumCoverInput = " -i \"" + state . AlbumCoverPath + "\"" ;
2017-04-28 21:17:26 +02:00
mapArgs = " -map 0:a -map 1:v -c:1:v copy" ;
2017-04-27 20:13:16 +02:00
metadata = " -metadata:s:v title=\"Album cover\" -metadata:s:v comment=\"Cover(Front)\"" ;
}
else
{
vn = " -vn" ;
}
var threads = GetNumberOfThreads ( state , encodingOptions , false ) ;
var inputModifier = GetInputModifier ( state , encodingOptions ) ;
return string . Format ( "{0} {1}{7}{8} -threads {2}{3} {4} -id3v2_version 3 -write_id3v1 1{6} -y \"{5}\"" ,
inputModifier ,
GetInputArgument ( state , encodingOptions ) ,
threads ,
vn ,
string . Join ( " " , audioTranscodeParams . ToArray ( ) ) ,
outputPath ,
metadata ,
albumCoverInput ,
mapArgs ) . Trim ( ) ;
}
2017-02-02 17:02:01 +01:00
}
}