EncodingHelper.cs 82 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Globalization;
  4. using System.IO;
  5. using System.Linq;
  6. using System.Threading;
  7. using MediaBrowser.Controller.Entities;
  8. using MediaBrowser.Model.Configuration;
  9. using MediaBrowser.Model.Dlna;
  10. using MediaBrowser.Model.Dto;
  11. using MediaBrowser.Model.Entities;
  12. using MediaBrowser.Model.IO;
  13. using MediaBrowser.Model.MediaInfo;
  14. using MediaBrowser.Model.Extensions;
  15. namespace MediaBrowser.Controller.MediaEncoding
  16. {
  17. public class EncodingHelper
  18. {
  19. private readonly CultureInfo _usCulture = new CultureInfo("en-US");
  20. private readonly IMediaEncoder _mediaEncoder;
  21. private readonly IFileSystem _fileSystem;
  22. private readonly ISubtitleEncoder _subtitleEncoder;
  23. public EncodingHelper(IMediaEncoder mediaEncoder, IFileSystem fileSystem, ISubtitleEncoder subtitleEncoder)
  24. {
  25. _mediaEncoder = mediaEncoder;
  26. _fileSystem = fileSystem;
  27. _subtitleEncoder = subtitleEncoder;
  28. }
  29. public string GetH264Encoder(EncodingJobInfo state, EncodingOptions encodingOptions)
  30. {
  31. var defaultEncoder = "libx264";
  32. // Only use alternative encoders for video files.
  33. // When using concat with folder rips, if the mfx session fails to initialize, ffmpeg will be stuck retrying and will not exit gracefully
  34. // Since transcoding of folder rips is expiremental anyway, it's not worth adding additional variables such as this.
  35. if (state.VideoType == VideoType.VideoFile)
  36. {
  37. var hwType = encodingOptions.HardwareAccelerationType;
  38. if (!encodingOptions.EnableHardwareEncoding)
  39. {
  40. hwType = null;
  41. }
  42. if (string.Equals(hwType, "qsv", StringComparison.OrdinalIgnoreCase) ||
  43. string.Equals(hwType, "h264_qsv", StringComparison.OrdinalIgnoreCase))
  44. {
  45. return GetAvailableEncoder("h264_qsv", defaultEncoder);
  46. }
  47. if (string.Equals(hwType, "nvenc", StringComparison.OrdinalIgnoreCase))
  48. {
  49. return GetAvailableEncoder("h264_nvenc", defaultEncoder);
  50. }
  51. if (string.Equals(hwType, "omx", StringComparison.OrdinalIgnoreCase))
  52. {
  53. return GetAvailableEncoder("h264_omx", defaultEncoder);
  54. }
  55. if (string.Equals(hwType, "h264_v4l2m2m", StringComparison.OrdinalIgnoreCase))
  56. {
  57. return GetAvailableEncoder("h264_v4l2m2m", defaultEncoder);
  58. }
  59. if (string.Equals(hwType, "vaapi", StringComparison.OrdinalIgnoreCase) && !string.IsNullOrWhiteSpace(encodingOptions.VaapiDevice))
  60. {
  61. if (IsVaapiSupported(state))
  62. {
  63. return GetAvailableEncoder("h264_vaapi", defaultEncoder);
  64. }
  65. }
  66. }
  67. return defaultEncoder;
  68. }
  69. private string GetAvailableEncoder(string preferredEncoder, string defaultEncoder)
  70. {
  71. if (_mediaEncoder.SupportsEncoder(preferredEncoder))
  72. {
  73. return preferredEncoder;
  74. }
  75. return defaultEncoder;
  76. }
  77. private bool IsVaapiSupported(EncodingJobInfo state)
  78. {
  79. var videoStream = state.VideoStream;
  80. if (videoStream != null)
  81. {
  82. // vaapi will throw an error with this input
  83. // [vaapi @ 0x7faed8000960] No VAAPI support for codec mpeg4 profile -99.
  84. if (string.Equals(videoStream.Codec, "mpeg4", StringComparison.OrdinalIgnoreCase))
  85. {
  86. return false;
  87. }
  88. }
  89. return true;
  90. }
  91. /// <summary>
  92. /// Gets the name of the output video codec
  93. /// </summary>
  94. public string GetVideoEncoder(EncodingJobInfo state, EncodingOptions encodingOptions)
  95. {
  96. var codec = state.OutputVideoCodec;
  97. if (!string.IsNullOrEmpty(codec))
  98. {
  99. if (string.Equals(codec, "h264", StringComparison.OrdinalIgnoreCase))
  100. {
  101. return GetH264Encoder(state, encodingOptions);
  102. }
  103. if (string.Equals(codec, "vpx", StringComparison.OrdinalIgnoreCase))
  104. {
  105. return "libvpx";
  106. }
  107. if (string.Equals(codec, "wmv", StringComparison.OrdinalIgnoreCase))
  108. {
  109. return "wmv2";
  110. }
  111. if (string.Equals(codec, "theora", StringComparison.OrdinalIgnoreCase))
  112. {
  113. return "libtheora";
  114. }
  115. return codec.ToLower();
  116. }
  117. return "copy";
  118. }
  119. /// <summary>
  120. /// Gets the user agent param.
  121. /// </summary>
  122. /// <param name="state">The state.</param>
  123. /// <returns>System.String.</returns>
  124. public string GetUserAgentParam(EncodingJobInfo state)
  125. {
  126. string useragent = null;
  127. state.RemoteHttpHeaders.TryGetValue("User-Agent", out useragent);
  128. if (!string.IsNullOrWhiteSpace(useragent))
  129. {
  130. return "-user-agent \"" + useragent + "\"";
  131. }
  132. return string.Empty;
  133. }
  134. public string GetInputFormat(string container)
  135. {
  136. if (string.IsNullOrWhiteSpace(container))
  137. {
  138. return null;
  139. }
  140. container = container.Replace("mkv", "matroska", StringComparison.OrdinalIgnoreCase);
  141. if (string.Equals(container, "ts", StringComparison.OrdinalIgnoreCase))
  142. {
  143. return "mpegts";
  144. }
  145. // For these need to find out the ffmpeg names
  146. if (string.Equals(container, "m2ts", StringComparison.OrdinalIgnoreCase))
  147. {
  148. return null;
  149. }
  150. if (string.Equals(container, "wmv", StringComparison.OrdinalIgnoreCase))
  151. {
  152. return null;
  153. }
  154. if (string.Equals(container, "mts", StringComparison.OrdinalIgnoreCase))
  155. {
  156. return null;
  157. }
  158. if (string.Equals(container, "vob", StringComparison.OrdinalIgnoreCase))
  159. {
  160. return null;
  161. }
  162. if (string.Equals(container, "mpg", StringComparison.OrdinalIgnoreCase))
  163. {
  164. return null;
  165. }
  166. if (string.Equals(container, "mpeg", StringComparison.OrdinalIgnoreCase))
  167. {
  168. return null;
  169. }
  170. if (string.Equals(container, "rec", StringComparison.OrdinalIgnoreCase))
  171. {
  172. return null;
  173. }
  174. if (string.Equals(container, "dvr-ms", StringComparison.OrdinalIgnoreCase))
  175. {
  176. return null;
  177. }
  178. if (string.Equals(container, "ogm", StringComparison.OrdinalIgnoreCase))
  179. {
  180. return null;
  181. }
  182. if (string.Equals(container, "divx", StringComparison.OrdinalIgnoreCase))
  183. {
  184. return null;
  185. }
  186. if (string.Equals(container, "tp", StringComparison.OrdinalIgnoreCase))
  187. {
  188. return null;
  189. }
  190. if (string.Equals(container, "rmvb", StringComparison.OrdinalIgnoreCase))
  191. {
  192. return null;
  193. }
  194. if (string.Equals(container, "rtp", StringComparison.OrdinalIgnoreCase))
  195. {
  196. return null;
  197. }
  198. // Seeing reported failures here, not sure yet if this is related to specfying input format
  199. if (string.Equals(container, "m4v", StringComparison.OrdinalIgnoreCase))
  200. {
  201. return null;
  202. }
  203. // obviously don't do this for strm files
  204. if (string.Equals(container, "strm", StringComparison.OrdinalIgnoreCase))
  205. {
  206. return null;
  207. }
  208. return container;
  209. }
  210. public string GetDecoderFromCodec(string codec)
  211. {
  212. // For these need to find out the ffmpeg names
  213. if (string.Equals(codec, "mp2", StringComparison.OrdinalIgnoreCase))
  214. {
  215. return null;
  216. }
  217. if (string.Equals(codec, "aac_latm", StringComparison.OrdinalIgnoreCase))
  218. {
  219. return null;
  220. }
  221. if (string.Equals(codec, "eac3", StringComparison.OrdinalIgnoreCase))
  222. {
  223. return null;
  224. }
  225. if (_mediaEncoder.SupportsDecoder(codec))
  226. {
  227. return codec;
  228. }
  229. return null;
  230. }
  231. /// <summary>
  232. /// Infers the audio codec based on the url
  233. /// </summary>
  234. /// <param name="url">The URL.</param>
  235. /// <returns>System.Nullable{AudioCodecs}.</returns>
  236. public string InferAudioCodec(string url)
  237. {
  238. var ext = Path.GetExtension(url);
  239. if (string.Equals(ext, ".mp3", StringComparison.OrdinalIgnoreCase))
  240. {
  241. return "mp3";
  242. }
  243. if (string.Equals(ext, ".aac", StringComparison.OrdinalIgnoreCase))
  244. {
  245. return "aac";
  246. }
  247. if (string.Equals(ext, ".wma", StringComparison.OrdinalIgnoreCase))
  248. {
  249. return "wma";
  250. }
  251. if (string.Equals(ext, ".ogg", StringComparison.OrdinalIgnoreCase))
  252. {
  253. return "vorbis";
  254. }
  255. if (string.Equals(ext, ".oga", StringComparison.OrdinalIgnoreCase))
  256. {
  257. return "vorbis";
  258. }
  259. if (string.Equals(ext, ".ogv", StringComparison.OrdinalIgnoreCase))
  260. {
  261. return "vorbis";
  262. }
  263. if (string.Equals(ext, ".webm", StringComparison.OrdinalIgnoreCase))
  264. {
  265. return "vorbis";
  266. }
  267. if (string.Equals(ext, ".webma", StringComparison.OrdinalIgnoreCase))
  268. {
  269. return "vorbis";
  270. }
  271. return "copy";
  272. }
  273. /// <summary>
  274. /// Infers the video codec.
  275. /// </summary>
  276. /// <param name="url">The URL.</param>
  277. /// <returns>System.Nullable{VideoCodecs}.</returns>
  278. public string InferVideoCodec(string url)
  279. {
  280. var ext = Path.GetExtension(url);
  281. if (string.Equals(ext, ".asf", StringComparison.OrdinalIgnoreCase))
  282. {
  283. return "wmv";
  284. }
  285. if (string.Equals(ext, ".webm", StringComparison.OrdinalIgnoreCase))
  286. {
  287. return "vpx";
  288. }
  289. if (string.Equals(ext, ".ogg", StringComparison.OrdinalIgnoreCase) || string.Equals(ext, ".ogv", StringComparison.OrdinalIgnoreCase))
  290. {
  291. return "theora";
  292. }
  293. if (string.Equals(ext, ".m3u8", StringComparison.OrdinalIgnoreCase) || string.Equals(ext, ".ts", StringComparison.OrdinalIgnoreCase))
  294. {
  295. return "h264";
  296. }
  297. return "copy";
  298. }
  299. public int GetVideoProfileScore(string profile)
  300. {
  301. var list = new List<string>
  302. {
  303. "Constrained Baseline",
  304. "Baseline",
  305. "Extended",
  306. "Main",
  307. "High",
  308. "Progressive High",
  309. "Constrained High"
  310. };
  311. return Array.FindIndex(list.ToArray(), t => string.Equals(t, profile, StringComparison.OrdinalIgnoreCase));
  312. }
  313. public string GetInputPathArgument(EncodingJobInfo state)
  314. {
  315. var protocol = state.InputProtocol;
  316. var mediaPath = state.MediaPath ?? string.Empty;
  317. var inputPath = new[] { mediaPath };
  318. if (state.IsInputVideo)
  319. {
  320. if (!(state.VideoType == VideoType.Iso && state.IsoMount == null))
  321. {
  322. inputPath = MediaEncoderHelpers.GetInputArgument(_fileSystem, mediaPath, state.InputProtocol, state.IsoMount, state.PlayableStreamFileNames);
  323. }
  324. }
  325. return _mediaEncoder.GetInputArgument(inputPath, protocol);
  326. }
  327. /// <summary>
  328. /// Gets the audio encoder.
  329. /// </summary>
  330. /// <param name="state">The state.</param>
  331. /// <returns>System.String.</returns>
  332. public string GetAudioEncoder(EncodingJobInfo state)
  333. {
  334. var codec = state.OutputAudioCodec;
  335. if (string.Equals(codec, "aac", StringComparison.OrdinalIgnoreCase))
  336. {
  337. return "aac -strict experimental";
  338. }
  339. if (string.Equals(codec, "mp3", StringComparison.OrdinalIgnoreCase))
  340. {
  341. return "libmp3lame";
  342. }
  343. if (string.Equals(codec, "vorbis", StringComparison.OrdinalIgnoreCase))
  344. {
  345. return "libvorbis";
  346. }
  347. if (string.Equals(codec, "wma", StringComparison.OrdinalIgnoreCase))
  348. {
  349. return "wmav2";
  350. }
  351. return codec.ToLower();
  352. }
  353. /// <summary>
  354. /// Gets the input argument.
  355. /// </summary>
  356. public string GetInputArgument(EncodingJobInfo state, EncodingOptions encodingOptions)
  357. {
  358. var request = state.BaseRequest;
  359. var arg = string.Format("-i {0}", GetInputPathArgument(state));
  360. if (state.SubtitleStream != null && state.SubtitleDeliveryMethod == SubtitleDeliveryMethod.Encode)
  361. {
  362. if (state.SubtitleStream.IsExternal && !state.SubtitleStream.IsTextSubtitleStream)
  363. {
  364. if (state.VideoStream != null && state.VideoStream.Width.HasValue)
  365. {
  366. // This is hacky but not sure how to get the exact subtitle resolution
  367. double height = state.VideoStream.Width.Value;
  368. height /= 16;
  369. height *= 9;
  370. arg += string.Format(" -canvas_size {0}:{1}", state.VideoStream.Width.Value.ToString(CultureInfo.InvariantCulture), Convert.ToInt32(height).ToString(CultureInfo.InvariantCulture));
  371. }
  372. var subtitlePath = state.SubtitleStream.Path;
  373. if (string.Equals(Path.GetExtension(subtitlePath), ".sub", StringComparison.OrdinalIgnoreCase))
  374. {
  375. var idxFile = Path.ChangeExtension(subtitlePath, ".idx");
  376. if (_fileSystem.FileExists(idxFile))
  377. {
  378. subtitlePath = idxFile;
  379. }
  380. }
  381. arg += " -i \"" + subtitlePath + "\"";
  382. }
  383. }
  384. if (state.IsVideoRequest)
  385. {
  386. if (GetVideoEncoder(state, encodingOptions).IndexOf("vaapi", StringComparison.OrdinalIgnoreCase) != -1)
  387. {
  388. var hasGraphicalSubs = state.SubtitleStream != null && !state.SubtitleStream.IsTextSubtitleStream && state.SubtitleDeliveryMethod == SubtitleDeliveryMethod.Encode;
  389. var hwOutputFormat = "vaapi";
  390. if (hasGraphicalSubs)
  391. {
  392. hwOutputFormat = "yuv420p";
  393. }
  394. arg = "-hwaccel vaapi -hwaccel_output_format " + hwOutputFormat + " -vaapi_device " + encodingOptions.VaapiDevice + " " + arg;
  395. }
  396. }
  397. return arg.Trim();
  398. }
  399. /// <summary>
  400. /// Determines whether the specified stream is H264.
  401. /// </summary>
  402. /// <param name="stream">The stream.</param>
  403. /// <returns><c>true</c> if the specified stream is H264; otherwise, <c>false</c>.</returns>
  404. public bool IsH264(MediaStream stream)
  405. {
  406. var codec = stream.Codec ?? string.Empty;
  407. return codec.IndexOf("264", StringComparison.OrdinalIgnoreCase) != -1 ||
  408. codec.IndexOf("avc", StringComparison.OrdinalIgnoreCase) != -1;
  409. }
  410. public string GetVideoBitrateParam(EncodingJobInfo state, string videoCodec)
  411. {
  412. var bitrate = state.OutputVideoBitrate;
  413. if (bitrate.HasValue)
  414. {
  415. if (string.Equals(videoCodec, "libvpx", StringComparison.OrdinalIgnoreCase))
  416. {
  417. // With vpx when crf is used, b:v becomes a max rate
  418. // 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.
  419. return string.Format(" -maxrate:v {0} -bufsize:v ({0}*2) -b:v {0}", bitrate.Value.ToString(_usCulture));
  420. }
  421. if (string.Equals(videoCodec, "msmpeg4", StringComparison.OrdinalIgnoreCase))
  422. {
  423. return string.Format(" -b:v {0}", bitrate.Value.ToString(_usCulture));
  424. }
  425. if (string.Equals(videoCodec, "libx264", StringComparison.OrdinalIgnoreCase))
  426. {
  427. // h264
  428. return string.Format(" -maxrate {0} -bufsize {1}",
  429. bitrate.Value.ToString(_usCulture),
  430. (bitrate.Value * 2).ToString(_usCulture));
  431. }
  432. // h264
  433. return string.Format(" -b:v {0} -maxrate {0} -bufsize {1}",
  434. bitrate.Value.ToString(_usCulture),
  435. (bitrate.Value * 2).ToString(_usCulture));
  436. }
  437. return string.Empty;
  438. }
  439. public string NormalizeTranscodingLevel(string videoCodec, string level)
  440. {
  441. double requestLevel;
  442. // Clients may direct play higher than level 41, but there's no reason to transcode higher
  443. if (double.TryParse(level, NumberStyles.Any, _usCulture, out requestLevel))
  444. {
  445. if (string.Equals(videoCodec, "h264", StringComparison.OrdinalIgnoreCase))
  446. {
  447. if (requestLevel > 41)
  448. {
  449. return "41";
  450. }
  451. }
  452. }
  453. return level;
  454. }
  455. /// <summary>
  456. /// Gets the text subtitle param.
  457. /// </summary>
  458. /// <param name="state">The state.</param>
  459. /// <returns>System.String.</returns>
  460. public string GetTextSubtitleParam(EncodingJobInfo state)
  461. {
  462. var seconds = Math.Round(TimeSpan.FromTicks(state.StartTimeTicks ?? 0).TotalSeconds);
  463. var setPtsParam = state.CopyTimestamps
  464. ? string.Empty
  465. : string.Format(",setpts=PTS -{0}/TB", seconds.ToString(_usCulture));
  466. if (state.SubtitleStream.IsExternal)
  467. {
  468. var subtitlePath = state.SubtitleStream.Path;
  469. var charsetParam = string.Empty;
  470. if (!string.IsNullOrEmpty(state.SubtitleStream.Language))
  471. {
  472. var charenc = _subtitleEncoder.GetSubtitleFileCharacterSet(subtitlePath, state.SubtitleStream.Language, state.MediaSource.Protocol, CancellationToken.None).Result;
  473. if (!string.IsNullOrEmpty(charenc))
  474. {
  475. charsetParam = ":charenc=" + charenc;
  476. }
  477. }
  478. // TODO: Perhaps also use original_size=1920x800 ??
  479. return string.Format("subtitles=filename='{0}'{1}{2}",
  480. _mediaEncoder.EscapeSubtitleFilterPath(subtitlePath),
  481. charsetParam,
  482. setPtsParam);
  483. }
  484. var mediaPath = state.MediaPath ?? string.Empty;
  485. return string.Format("subtitles='{0}:si={1}'{2}",
  486. _mediaEncoder.EscapeSubtitleFilterPath(mediaPath),
  487. state.InternalSubtitleStreamOffset.ToString(_usCulture),
  488. setPtsParam);
  489. }
  490. public double? GetFramerateParam(EncodingJobInfo state)
  491. {
  492. var request = state.BaseRequest;
  493. if (request.Framerate.HasValue)
  494. {
  495. return request.Framerate.Value;
  496. }
  497. var maxrate = request.MaxFramerate;
  498. if (maxrate.HasValue && state.VideoStream != null)
  499. {
  500. var contentRate = state.VideoStream.AverageFrameRate ?? state.VideoStream.RealFrameRate;
  501. if (contentRate.HasValue && contentRate.Value > maxrate.Value)
  502. {
  503. return maxrate;
  504. }
  505. }
  506. return null;
  507. }
  508. /// <summary>
  509. /// Gets the video bitrate to specify on the command line
  510. /// </summary>
  511. public string GetVideoQualityParam(EncodingJobInfo state, string videoEncoder, EncodingOptions encodingOptions, string defaultH264Preset)
  512. {
  513. var param = string.Empty;
  514. var isVc1 = state.VideoStream != null &&
  515. string.Equals(state.VideoStream.Codec, "vc1", StringComparison.OrdinalIgnoreCase);
  516. if (string.Equals(videoEncoder, "libx264", StringComparison.OrdinalIgnoreCase))
  517. {
  518. if (!string.IsNullOrWhiteSpace(encodingOptions.H264Preset))
  519. {
  520. param += "-preset " + encodingOptions.H264Preset;
  521. }
  522. else
  523. {
  524. param += "-preset " + defaultH264Preset;
  525. }
  526. if (encodingOptions.H264Crf >= 0 && encodingOptions.H264Crf <= 51)
  527. {
  528. param += " -crf " + encodingOptions.H264Crf.ToString(CultureInfo.InvariantCulture);
  529. }
  530. else
  531. {
  532. param += " -crf 23";
  533. }
  534. }
  535. else if (string.Equals(videoEncoder, "libx265", StringComparison.OrdinalIgnoreCase))
  536. {
  537. param += "-preset fast";
  538. param += " -crf 28";
  539. }
  540. // h264 (h264_qsv)
  541. else if (string.Equals(videoEncoder, "h264_qsv", StringComparison.OrdinalIgnoreCase))
  542. {
  543. param += "-preset 7 -look_ahead 0";
  544. }
  545. // h264 (h264_nvenc)
  546. else if (string.Equals(videoEncoder, "h264_nvenc", StringComparison.OrdinalIgnoreCase))
  547. {
  548. param += "-preset default";
  549. }
  550. // webm
  551. else if (string.Equals(videoEncoder, "libvpx", StringComparison.OrdinalIgnoreCase))
  552. {
  553. // Values 0-3, 0 being highest quality but slower
  554. var profileScore = 0;
  555. string crf;
  556. var qmin = "0";
  557. var qmax = "50";
  558. crf = "10";
  559. if (isVc1)
  560. {
  561. profileScore++;
  562. }
  563. // Max of 2
  564. profileScore = Math.Min(profileScore, 2);
  565. // http://www.webmproject.org/docs/encoder-parameters/
  566. param += string.Format("-speed 16 -quality good -profile:v {0} -slices 8 -crf {1} -qmin {2} -qmax {3}",
  567. profileScore.ToString(_usCulture),
  568. crf,
  569. qmin,
  570. qmax);
  571. }
  572. else if (string.Equals(videoEncoder, "mpeg4", StringComparison.OrdinalIgnoreCase))
  573. {
  574. param += "-mbd rd -flags +mv4+aic -trellis 2 -cmp 2 -subcmp 2 -bf 2";
  575. }
  576. // asf/wmv
  577. else if (string.Equals(videoEncoder, "wmv2", StringComparison.OrdinalIgnoreCase))
  578. {
  579. param += "-qmin 2";
  580. }
  581. else if (string.Equals(videoEncoder, "msmpeg4", StringComparison.OrdinalIgnoreCase))
  582. {
  583. param += "-mbd 2";
  584. }
  585. param += GetVideoBitrateParam(state, videoEncoder);
  586. var framerate = GetFramerateParam(state);
  587. if (framerate.HasValue)
  588. {
  589. param += string.Format(" -r {0}", framerate.Value.ToString(_usCulture));
  590. }
  591. var request = state.BaseRequest;
  592. if (!string.IsNullOrEmpty(request.Profile))
  593. {
  594. if (!string.Equals(videoEncoder, "h264_omx", StringComparison.OrdinalIgnoreCase) &&
  595. !string.Equals(videoEncoder, "h264_vaapi", StringComparison.OrdinalIgnoreCase) &&
  596. !string.Equals(videoEncoder, "h264_v4l2m2m", StringComparison.OrdinalIgnoreCase))
  597. {
  598. // not supported by h264_omx
  599. param += " -profile:v " + request.Profile;
  600. }
  601. }
  602. if (!string.IsNullOrEmpty(request.Level))
  603. {
  604. var level = NormalizeTranscodingLevel(state.OutputVideoCodec, request.Level);
  605. // h264_qsv and h264_nvenc expect levels to be expressed as a decimal. libx264 supports decimal and non-decimal format
  606. // also needed for libx264 due to https://trac.ffmpeg.org/ticket/3307
  607. if (string.Equals(videoEncoder, "h264_qsv", StringComparison.OrdinalIgnoreCase) ||
  608. string.Equals(videoEncoder, "libx264", StringComparison.OrdinalIgnoreCase))
  609. {
  610. switch (level)
  611. {
  612. case "30":
  613. param += " -level 3.0";
  614. break;
  615. case "31":
  616. param += " -level 3.1";
  617. break;
  618. case "32":
  619. param += " -level 3.2";
  620. break;
  621. case "40":
  622. param += " -level 4.0";
  623. break;
  624. case "41":
  625. param += " -level 4.1";
  626. break;
  627. case "42":
  628. param += " -level 4.2";
  629. break;
  630. case "50":
  631. param += " -level 5.0";
  632. break;
  633. case "51":
  634. param += " -level 5.1";
  635. break;
  636. case "52":
  637. param += " -level 5.2";
  638. break;
  639. default:
  640. param += " -level " + level;
  641. break;
  642. }
  643. }
  644. // nvenc doesn't decode with param -level set ?!
  645. else if (string.Equals(videoEncoder, "h264_nvenc", StringComparison.OrdinalIgnoreCase))
  646. {
  647. //param += "";
  648. }
  649. else if (!string.Equals(videoEncoder, "h264_omx", StringComparison.OrdinalIgnoreCase))
  650. {
  651. param += " -level " + level;
  652. }
  653. }
  654. if (string.Equals(videoEncoder, "libx264", StringComparison.OrdinalIgnoreCase))
  655. {
  656. param += " -x264opts:0 subme=0:me_range=4:rc_lookahead=10:me=dia:no_chroma_me:8x8dct=0:partitions=none";
  657. }
  658. if (!string.Equals(videoEncoder, "h264_omx", StringComparison.OrdinalIgnoreCase) &&
  659. !string.Equals(videoEncoder, "h264_qsv", StringComparison.OrdinalIgnoreCase) &&
  660. !string.Equals(videoEncoder, "h264_vaapi", StringComparison.OrdinalIgnoreCase) &&
  661. !string.Equals(videoEncoder, "h264_v4l2m2m", StringComparison.OrdinalIgnoreCase))
  662. {
  663. param = "-pix_fmt yuv420p " + param;
  664. }
  665. if (string.Equals(videoEncoder, "h264_v4l2m2m", StringComparison.OrdinalIgnoreCase))
  666. {
  667. param = "-pix_fmt nv21 " + param;
  668. }
  669. return param;
  670. }
  671. public bool CanStreamCopyVideo(EncodingJobInfo state, MediaStream videoStream)
  672. {
  673. var request = state.BaseRequest;
  674. if (!request.AllowVideoStreamCopy)
  675. {
  676. return false;
  677. }
  678. if (state.EnableMpDecimate)
  679. {
  680. return false;
  681. }
  682. if (videoStream.IsInterlaced)
  683. {
  684. if (request.DeInterlace)
  685. {
  686. return false;
  687. }
  688. }
  689. if (videoStream.IsAnamorphic ?? false)
  690. {
  691. if (request.RequireNonAnamorphic)
  692. {
  693. return false;
  694. }
  695. }
  696. // Can't stream copy if we're burning in subtitles
  697. if (request.SubtitleStreamIndex.HasValue)
  698. {
  699. if (state.SubtitleDeliveryMethod == SubtitleDeliveryMethod.Encode)
  700. {
  701. return false;
  702. }
  703. }
  704. if (string.Equals("h264", videoStream.Codec, StringComparison.OrdinalIgnoreCase))
  705. {
  706. if (videoStream.IsAVC.HasValue && !videoStream.IsAVC.Value && request.RequireAvc)
  707. {
  708. return false;
  709. }
  710. }
  711. // Source and target codecs must match
  712. if (string.IsNullOrEmpty(videoStream.Codec) || !state.SupportedVideoCodecs.Contains(videoStream.Codec, StringComparer.OrdinalIgnoreCase))
  713. {
  714. return false;
  715. }
  716. // If client is requesting a specific video profile, it must match the source
  717. if (!string.IsNullOrEmpty(request.Profile))
  718. {
  719. if (string.IsNullOrEmpty(videoStream.Profile))
  720. {
  721. //return false;
  722. }
  723. if (!string.IsNullOrEmpty(videoStream.Profile) && !string.Equals(request.Profile, videoStream.Profile, StringComparison.OrdinalIgnoreCase))
  724. {
  725. var currentScore = GetVideoProfileScore(videoStream.Profile);
  726. var requestedScore = GetVideoProfileScore(request.Profile);
  727. if (currentScore == -1 || currentScore > requestedScore)
  728. {
  729. return false;
  730. }
  731. }
  732. }
  733. // Video width must fall within requested value
  734. if (request.MaxWidth.HasValue)
  735. {
  736. if (!videoStream.Width.HasValue || videoStream.Width.Value > request.MaxWidth.Value)
  737. {
  738. return false;
  739. }
  740. }
  741. // Video height must fall within requested value
  742. if (request.MaxHeight.HasValue)
  743. {
  744. if (!videoStream.Height.HasValue || videoStream.Height.Value > request.MaxHeight.Value)
  745. {
  746. return false;
  747. }
  748. }
  749. // Video framerate must fall within requested value
  750. var requestedFramerate = request.MaxFramerate ?? request.Framerate;
  751. if (requestedFramerate.HasValue)
  752. {
  753. var videoFrameRate = videoStream.AverageFrameRate ?? videoStream.RealFrameRate;
  754. if (!videoFrameRate.HasValue || videoFrameRate.Value > requestedFramerate.Value)
  755. {
  756. return false;
  757. }
  758. }
  759. // Video bitrate must fall within requested value
  760. if (request.VideoBitRate.HasValue)
  761. {
  762. if (!videoStream.BitRate.HasValue || videoStream.BitRate.Value > request.VideoBitRate.Value)
  763. {
  764. return false;
  765. }
  766. }
  767. if (request.MaxVideoBitDepth.HasValue)
  768. {
  769. if (videoStream.BitDepth.HasValue && videoStream.BitDepth.Value > request.MaxVideoBitDepth.Value)
  770. {
  771. return false;
  772. }
  773. }
  774. if (request.MaxRefFrames.HasValue)
  775. {
  776. if (videoStream.RefFrames.HasValue && videoStream.RefFrames.Value > request.MaxRefFrames.Value)
  777. {
  778. return false;
  779. }
  780. }
  781. // If a specific level was requested, the source must match or be less than
  782. if (!string.IsNullOrEmpty(request.Level))
  783. {
  784. double requestLevel;
  785. if (double.TryParse(request.Level, NumberStyles.Any, _usCulture, out requestLevel))
  786. {
  787. if (!videoStream.Level.HasValue)
  788. {
  789. //return false;
  790. }
  791. if (videoStream.Level.HasValue && videoStream.Level.Value > requestLevel)
  792. {
  793. return false;
  794. }
  795. }
  796. }
  797. return request.EnableAutoStreamCopy;
  798. }
  799. public bool CanStreamCopyAudio(EncodingJobInfo state, MediaStream audioStream, List<string> supportedAudioCodecs)
  800. {
  801. var request = state.BaseRequest;
  802. if (!request.AllowAudioStreamCopy)
  803. {
  804. return false;
  805. }
  806. // Source and target codecs must match
  807. if (string.IsNullOrEmpty(audioStream.Codec) || !supportedAudioCodecs.Contains(audioStream.Codec, StringComparer.OrdinalIgnoreCase))
  808. {
  809. return false;
  810. }
  811. // Channels must fall within requested value
  812. var channels = request.AudioChannels ?? request.MaxAudioChannels;
  813. if (channels.HasValue)
  814. {
  815. if (!audioStream.Channels.HasValue || audioStream.Channels.Value <= 0)
  816. {
  817. return false;
  818. }
  819. if (audioStream.Channels.Value > channels.Value)
  820. {
  821. return false;
  822. }
  823. }
  824. // Sample rate must fall within requested value
  825. if (request.AudioSampleRate.HasValue)
  826. {
  827. if (!audioStream.SampleRate.HasValue || audioStream.SampleRate.Value <= 0)
  828. {
  829. return false;
  830. }
  831. if (audioStream.SampleRate.Value > request.AudioSampleRate.Value)
  832. {
  833. return false;
  834. }
  835. }
  836. // Video bitrate must fall within requested value
  837. if (request.AudioBitRate.HasValue)
  838. {
  839. if (!audioStream.BitRate.HasValue || audioStream.BitRate.Value <= 0)
  840. {
  841. return false;
  842. }
  843. if (audioStream.BitRate.Value > request.AudioBitRate.Value)
  844. {
  845. return false;
  846. }
  847. }
  848. return request.EnableAutoStreamCopy;
  849. }
  850. public int? GetVideoBitrateParamValue(BaseEncodingJobOptions request, MediaStream videoStream, string outputVideoCodec)
  851. {
  852. var bitrate = request.VideoBitRate;
  853. if (videoStream != null)
  854. {
  855. var isUpscaling = request.Height.HasValue && videoStream.Height.HasValue &&
  856. request.Height.Value > videoStream.Height.Value;
  857. if (request.Width.HasValue && videoStream.Width.HasValue &&
  858. request.Width.Value > videoStream.Width.Value)
  859. {
  860. isUpscaling = true;
  861. }
  862. // Don't allow bitrate increases unless upscaling
  863. if (!isUpscaling)
  864. {
  865. if (bitrate.HasValue && videoStream.BitRate.HasValue)
  866. {
  867. bitrate = GetMinBitrate(bitrate.Value, videoStream.BitRate.Value);
  868. }
  869. }
  870. }
  871. if (bitrate.HasValue)
  872. {
  873. var inputVideoCodec = videoStream == null ? null : videoStream.Codec;
  874. bitrate = ResolutionNormalizer.ScaleBitrate(bitrate.Value, inputVideoCodec, outputVideoCodec);
  875. // If a max bitrate was requested, don't let the scaled bitrate exceed it
  876. if (request.VideoBitRate.HasValue)
  877. {
  878. bitrate = GetMinBitrate(bitrate.Value, request.VideoBitRate.Value);
  879. }
  880. }
  881. return bitrate;
  882. }
  883. private int GetMinBitrate(int sourceBitrate, int requestedBitrate)
  884. {
  885. if (sourceBitrate <= 2000000)
  886. {
  887. sourceBitrate *= 2;
  888. }
  889. else if (sourceBitrate <= 3000000)
  890. {
  891. sourceBitrate = Convert.ToInt32(sourceBitrate * 1.5);
  892. }
  893. var bitrate = Math.Min(sourceBitrate, requestedBitrate);
  894. return bitrate;
  895. }
  896. public int? GetAudioBitrateParam(BaseEncodingJobOptions request, MediaStream audioStream)
  897. {
  898. if (request.AudioBitRate.HasValue)
  899. {
  900. // Make sure we don't request a bitrate higher than the source
  901. var currentBitrate = audioStream == null ? request.AudioBitRate.Value : audioStream.BitRate ?? request.AudioBitRate.Value;
  902. // Don't encode any higher than this
  903. return Math.Min(384000, request.AudioBitRate.Value);
  904. //return Math.Min(currentBitrate, request.AudioBitRate.Value);
  905. }
  906. return null;
  907. }
  908. public string GetAudioFilterParam(EncodingJobInfo state, EncodingOptions encodingOptions, bool isHls)
  909. {
  910. var channels = state.OutputAudioChannels;
  911. var filters = new List<string>();
  912. // Boost volume to 200% when downsampling from 6ch to 2ch
  913. if (channels.HasValue && channels.Value <= 2)
  914. {
  915. if (state.AudioStream != null && state.AudioStream.Channels.HasValue && state.AudioStream.Channels.Value > 5 && !encodingOptions.DownMixAudioBoost.Equals(1))
  916. {
  917. filters.Add("volume=" + encodingOptions.DownMixAudioBoost.ToString(_usCulture));
  918. }
  919. }
  920. if (state.SubtitleStream != null && state.SubtitleStream.IsTextSubtitleStream && state.SubtitleDeliveryMethod == SubtitleDeliveryMethod.Encode && !state.CopyTimestamps)
  921. {
  922. var seconds = TimeSpan.FromTicks(state.StartTimeTicks ?? 0).TotalSeconds;
  923. filters.Add(string.Format("asetpts=PTS-{0}/TB", Math.Round(seconds).ToString(_usCulture)));
  924. }
  925. if (filters.Count > 0)
  926. {
  927. return "-af \"" + string.Join(",", filters.ToArray()) + "\"";
  928. }
  929. return string.Empty;
  930. }
  931. /// <summary>
  932. /// Gets the number of audio channels to specify on the command line
  933. /// </summary>
  934. /// <param name="request">The request.</param>
  935. /// <param name="audioStream">The audio stream.</param>
  936. /// <param name="outputAudioCodec">The output audio codec.</param>
  937. /// <returns>System.Nullable{System.Int32}.</returns>
  938. public int? GetNumAudioChannelsParam(BaseEncodingJobOptions request, MediaStream audioStream, string outputAudioCodec)
  939. {
  940. var inputChannels = audioStream == null
  941. ? null
  942. : audioStream.Channels;
  943. if (inputChannels <= 0)
  944. {
  945. inputChannels = null;
  946. }
  947. int? transcoderChannelLimit = null;
  948. var codec = outputAudioCodec ?? string.Empty;
  949. if (codec.IndexOf("wma", StringComparison.OrdinalIgnoreCase) != -1)
  950. {
  951. // wmav2 currently only supports two channel output
  952. transcoderChannelLimit = 2;
  953. }
  954. else if (codec.IndexOf("mp3", StringComparison.OrdinalIgnoreCase) != -1)
  955. {
  956. // libmp3lame currently only supports two channel output
  957. transcoderChannelLimit = 2;
  958. }
  959. else
  960. {
  961. // If we don't have any media info then limit it to 6 to prevent encoding errors due to asking for too many channels
  962. transcoderChannelLimit = 6;
  963. }
  964. var isTranscodingAudio = !string.Equals(codec, "copy", StringComparison.OrdinalIgnoreCase);
  965. int? resultChannels = null;
  966. if (isTranscodingAudio)
  967. {
  968. resultChannels = request.TranscodingMaxAudioChannels;
  969. }
  970. resultChannels = resultChannels ?? request.MaxAudioChannels ?? request.AudioChannels;
  971. if (inputChannels.HasValue)
  972. {
  973. resultChannels = resultChannels.HasValue
  974. ? Math.Min(resultChannels.Value, inputChannels.Value)
  975. : inputChannels.Value;
  976. }
  977. if (isTranscodingAudio && transcoderChannelLimit.HasValue)
  978. {
  979. resultChannels = resultChannels.HasValue
  980. ? Math.Min(resultChannels.Value, transcoderChannelLimit.Value)
  981. : transcoderChannelLimit.Value;
  982. }
  983. return resultChannels ?? request.AudioChannels;
  984. }
  985. /// <summary>
  986. /// Enforces the resolution limit.
  987. /// </summary>
  988. /// <param name="state">The state.</param>
  989. public void EnforceResolutionLimit(EncodingJobInfo state)
  990. {
  991. var videoRequest = state.BaseRequest;
  992. // Switch the incoming params to be ceilings rather than fixed values
  993. videoRequest.MaxWidth = videoRequest.MaxWidth ?? videoRequest.Width;
  994. videoRequest.MaxHeight = videoRequest.MaxHeight ?? videoRequest.Height;
  995. videoRequest.Width = null;
  996. videoRequest.Height = null;
  997. }
  998. /// <summary>
  999. /// Gets the fast seek command line parameter.
  1000. /// </summary>
  1001. /// <param name="request">The request.</param>
  1002. /// <returns>System.String.</returns>
  1003. /// <value>The fast seek command line parameter.</value>
  1004. public string GetFastSeekCommandLineParameter(BaseEncodingJobOptions request)
  1005. {
  1006. var time = request.StartTimeTicks ?? 0;
  1007. if (time > 0)
  1008. {
  1009. return string.Format("-ss {0}", _mediaEncoder.GetTimeParameter(time));
  1010. }
  1011. return string.Empty;
  1012. }
  1013. /// <summary>
  1014. /// Gets the map args.
  1015. /// </summary>
  1016. /// <param name="state">The state.</param>
  1017. /// <returns>System.String.</returns>
  1018. public string GetMapArgs(EncodingJobInfo state)
  1019. {
  1020. // If we don't have known media info
  1021. // If input is video, use -sn to drop subtitles
  1022. // Otherwise just return empty
  1023. if (state.VideoStream == null && state.AudioStream == null)
  1024. {
  1025. return state.IsInputVideo ? "-sn" : string.Empty;
  1026. }
  1027. // We have media info, but we don't know the stream indexes
  1028. if (state.VideoStream != null && state.VideoStream.Index == -1)
  1029. {
  1030. return "-sn";
  1031. }
  1032. // We have media info, but we don't know the stream indexes
  1033. if (state.AudioStream != null && state.AudioStream.Index == -1)
  1034. {
  1035. return state.IsInputVideo ? "-sn" : string.Empty;
  1036. }
  1037. var args = string.Empty;
  1038. if (state.VideoStream != null)
  1039. {
  1040. args += string.Format("-map 0:{0}", state.VideoStream.Index);
  1041. }
  1042. else
  1043. {
  1044. // No known video stream
  1045. args += "-vn";
  1046. }
  1047. if (state.AudioStream != null)
  1048. {
  1049. args += string.Format(" -map 0:{0}", state.AudioStream.Index);
  1050. }
  1051. else
  1052. {
  1053. args += " -map -0:a";
  1054. }
  1055. var subtitleMethod = state.SubtitleDeliveryMethod;
  1056. if (state.SubtitleStream == null || subtitleMethod == SubtitleDeliveryMethod.Hls)
  1057. {
  1058. args += " -map -0:s";
  1059. }
  1060. else if (subtitleMethod == SubtitleDeliveryMethod.Embed)
  1061. {
  1062. args += string.Format(" -map 0:{0}", state.SubtitleStream.Index);
  1063. }
  1064. else if (state.SubtitleStream.IsExternal && !state.SubtitleStream.IsTextSubtitleStream)
  1065. {
  1066. args += " -map 1:0 -sn";
  1067. }
  1068. return args;
  1069. }
  1070. /// <summary>
  1071. /// Determines which stream will be used for playback
  1072. /// </summary>
  1073. /// <param name="allStream">All stream.</param>
  1074. /// <param name="desiredIndex">Index of the desired.</param>
  1075. /// <param name="type">The type.</param>
  1076. /// <param name="returnFirstIfNoIndex">if set to <c>true</c> [return first if no index].</param>
  1077. /// <returns>MediaStream.</returns>
  1078. public MediaStream GetMediaStream(IEnumerable<MediaStream> allStream, int? desiredIndex, MediaStreamType type, bool returnFirstIfNoIndex = true)
  1079. {
  1080. var streams = allStream.Where(s => s.Type == type).OrderBy(i => i.Index).ToList();
  1081. if (desiredIndex.HasValue)
  1082. {
  1083. var stream = streams.FirstOrDefault(s => s.Index == desiredIndex.Value);
  1084. if (stream != null)
  1085. {
  1086. return stream;
  1087. }
  1088. }
  1089. if (returnFirstIfNoIndex && type == MediaStreamType.Audio)
  1090. {
  1091. return streams.FirstOrDefault(i => i.Channels.HasValue && i.Channels.Value > 0) ??
  1092. streams.FirstOrDefault();
  1093. }
  1094. // Just return the first one
  1095. return returnFirstIfNoIndex ? streams.FirstOrDefault() : null;
  1096. }
  1097. /// <summary>
  1098. /// Gets the internal graphical subtitle param.
  1099. /// </summary>
  1100. /// <param name="state">The state.</param>
  1101. /// <param name="outputVideoCodec">The output video codec.</param>
  1102. /// <returns>System.String.</returns>
  1103. public string GetGraphicalSubtitleParam(EncodingJobInfo state, string outputVideoCodec)
  1104. {
  1105. var outputSizeParam = string.Empty;
  1106. var request = state.BaseRequest;
  1107. // Add resolution params, if specified
  1108. if (request.Width.HasValue || request.Height.HasValue || request.MaxHeight.HasValue || request.MaxWidth.HasValue)
  1109. {
  1110. outputSizeParam = GetOutputSizeParam(state, outputVideoCodec).TrimEnd('"');
  1111. if (string.Equals(outputVideoCodec, "h264_vaapi", StringComparison.OrdinalIgnoreCase))
  1112. {
  1113. outputSizeParam = "," + outputSizeParam.Substring(outputSizeParam.IndexOf("format", StringComparison.OrdinalIgnoreCase));
  1114. }
  1115. else
  1116. {
  1117. outputSizeParam = "," + outputSizeParam.Substring(outputSizeParam.IndexOf("scale", StringComparison.OrdinalIgnoreCase));
  1118. }
  1119. }
  1120. if (string.Equals(outputVideoCodec, "h264_vaapi", StringComparison.OrdinalIgnoreCase) && outputSizeParam.Length == 0)
  1121. {
  1122. outputSizeParam = ",format=nv12|vaapi,hwupload";
  1123. }
  1124. var videoSizeParam = string.Empty;
  1125. if (state.VideoStream != null && state.VideoStream.Width.HasValue && state.VideoStream.Height.HasValue)
  1126. {
  1127. videoSizeParam = string.Format("scale={0}:{1}", state.VideoStream.Width.Value.ToString(_usCulture), state.VideoStream.Height.Value.ToString(_usCulture));
  1128. }
  1129. var mapPrefix = state.SubtitleStream.IsExternal ?
  1130. 1 :
  1131. 0;
  1132. var subtitleStreamIndex = state.SubtitleStream.IsExternal
  1133. ? 0
  1134. : state.SubtitleStream.Index;
  1135. return string.Format(" -filter_complex \"[{0}:{1}]{4}[sub] ; [0:{2}] [sub] overlay{3}\"",
  1136. mapPrefix.ToString(_usCulture),
  1137. subtitleStreamIndex.ToString(_usCulture),
  1138. state.VideoStream.Index.ToString(_usCulture),
  1139. outputSizeParam,
  1140. videoSizeParam);
  1141. }
  1142. /// <summary>
  1143. /// If we're going to put a fixed size on the command line, this will calculate it
  1144. /// </summary>
  1145. /// <param name="state">The state.</param>
  1146. /// <param name="outputVideoCodec">The output video codec.</param>
  1147. /// <param name="allowTimeStampCopy">if set to <c>true</c> [allow time stamp copy].</param>
  1148. /// <returns>System.String.</returns>
  1149. public string GetOutputSizeParam(EncodingJobInfo state,
  1150. string outputVideoCodec,
  1151. bool allowTimeStampCopy = true)
  1152. {
  1153. // http://sonnati.wordpress.com/2012/10/19/ffmpeg-the-swiss-army-knife-of-internet-streaming-part-vi/
  1154. var request = state.BaseRequest;
  1155. var filters = new List<string>();
  1156. if (string.Equals(outputVideoCodec, "h264_vaapi", StringComparison.OrdinalIgnoreCase))
  1157. {
  1158. filters.Add("format=nv12|vaapi");
  1159. filters.Add("hwupload");
  1160. }
  1161. if (state.DeInterlace && !string.Equals(outputVideoCodec, "h264_vaapi", StringComparison.OrdinalIgnoreCase))
  1162. {
  1163. filters.Add("yadif=0:-1:0");
  1164. }
  1165. if (string.Equals(outputVideoCodec, "h264_vaapi", StringComparison.OrdinalIgnoreCase))
  1166. {
  1167. // Work around vaapi's reduced scaling features
  1168. var scaler = "scale_vaapi";
  1169. // Given the input dimensions (inputWidth, inputHeight), determine the output dimensions
  1170. // (outputWidth, outputHeight). The user may request precise output dimensions or maximum
  1171. // output dimensions. Output dimensions are guaranteed to be even.
  1172. decimal inputWidth = Convert.ToDecimal(state.VideoStream.Width);
  1173. decimal inputHeight = Convert.ToDecimal(state.VideoStream.Height);
  1174. decimal outputWidth = request.Width.HasValue ? Convert.ToDecimal(request.Width.Value) : inputWidth;
  1175. decimal outputHeight = request.Height.HasValue ? Convert.ToDecimal(request.Height.Value) : inputHeight;
  1176. decimal maximumWidth = request.MaxWidth.HasValue ? Convert.ToDecimal(request.MaxWidth.Value) : outputWidth;
  1177. decimal maximumHeight = request.MaxHeight.HasValue ? Convert.ToDecimal(request.MaxHeight.Value) : outputHeight;
  1178. if (outputWidth > maximumWidth || outputHeight > maximumHeight)
  1179. {
  1180. var scale = Math.Min(maximumWidth / outputWidth, maximumHeight / outputHeight);
  1181. outputWidth = Math.Min(maximumWidth, Math.Truncate(outputWidth * scale));
  1182. outputHeight = Math.Min(maximumHeight, Math.Truncate(outputHeight * scale));
  1183. }
  1184. outputWidth = 2 * Math.Truncate(outputWidth / 2);
  1185. outputHeight = 2 * Math.Truncate(outputHeight / 2);
  1186. if (outputWidth != inputWidth || outputHeight != inputHeight)
  1187. {
  1188. filters.Add(string.Format("{0}=w={1}:h={2}", scaler, outputWidth.ToString(_usCulture), outputHeight.ToString(_usCulture)));
  1189. }
  1190. }
  1191. else
  1192. {
  1193. // If fixed dimensions were supplied
  1194. if (request.Width.HasValue && request.Height.HasValue)
  1195. {
  1196. var widthParam = request.Width.Value.ToString(_usCulture);
  1197. var heightParam = request.Height.Value.ToString(_usCulture);
  1198. filters.Add(string.Format("scale=trunc({0}/2)*2:trunc({1}/2)*2", widthParam, heightParam));
  1199. }
  1200. // 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
  1201. else if (request.MaxWidth.HasValue && request.MaxHeight.HasValue)
  1202. {
  1203. var maxWidthParam = request.MaxWidth.Value.ToString(_usCulture);
  1204. var maxHeightParam = request.MaxHeight.Value.ToString(_usCulture);
  1205. 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));
  1206. }
  1207. // If a fixed width was requested
  1208. else if (request.Width.HasValue)
  1209. {
  1210. var widthParam = request.Width.Value.ToString(_usCulture);
  1211. filters.Add(string.Format("scale={0}:trunc(ow/a/2)*2", widthParam));
  1212. }
  1213. // If a fixed height was requested
  1214. else if (request.Height.HasValue)
  1215. {
  1216. var heightParam = request.Height.Value.ToString(_usCulture);
  1217. filters.Add(string.Format("scale=trunc(oh*a/2)*2:{0}", heightParam));
  1218. }
  1219. // If a max width was requested
  1220. else if (request.MaxWidth.HasValue)
  1221. {
  1222. var maxWidthParam = request.MaxWidth.Value.ToString(_usCulture);
  1223. filters.Add(string.Format("scale=trunc(min(max(iw\\,ih*dar)\\,{0})/2)*2:trunc(ow/dar/2)*2", maxWidthParam));
  1224. }
  1225. // If a max height was requested
  1226. else if (request.MaxHeight.HasValue)
  1227. {
  1228. var maxHeightParam = request.MaxHeight.Value.ToString(_usCulture);
  1229. filters.Add(string.Format("scale=trunc(oh*a/2)*2:min(max(iw/dar\\,ih)\\,{0})", maxHeightParam));
  1230. }
  1231. }
  1232. var output = string.Empty;
  1233. if (state.SubtitleStream != null && state.SubtitleStream.IsTextSubtitleStream && state.SubtitleDeliveryMethod == SubtitleDeliveryMethod.Encode)
  1234. {
  1235. var subParam = GetTextSubtitleParam(state);
  1236. filters.Add(subParam);
  1237. if (allowTimeStampCopy)
  1238. {
  1239. output += " -copyts";
  1240. }
  1241. }
  1242. if (state.EnableMpDecimate)
  1243. {
  1244. filters.Add("mpdecimate,setpts=N/FRAME_RATE/TB");
  1245. }
  1246. if (filters.Count > 0)
  1247. {
  1248. output += string.Format(" -vf \"{0}\"", string.Join(",", filters.ToArray()));
  1249. }
  1250. return output;
  1251. }
  1252. /// <summary>
  1253. /// Gets the number of threads.
  1254. /// </summary>
  1255. /// <returns>System.Int32.</returns>
  1256. public int GetNumberOfThreads(EncodingJobInfo state, EncodingOptions encodingOptions, bool isWebm)
  1257. {
  1258. var threads = GetNumberOfThreadsInternal(state, encodingOptions, isWebm);
  1259. if (state.BaseRequest.CpuCoreLimit.HasValue && state.BaseRequest.CpuCoreLimit.Value > 0)
  1260. {
  1261. threads = Math.Min(threads, state.BaseRequest.CpuCoreLimit.Value);
  1262. }
  1263. return threads;
  1264. }
  1265. public void TryStreamCopy(EncodingJobInfo state)
  1266. {
  1267. if (state.VideoStream != null && CanStreamCopyVideo(state, state.VideoStream))
  1268. {
  1269. state.OutputVideoCodec = "copy";
  1270. }
  1271. else
  1272. {
  1273. var user = state.User;
  1274. // If the user doesn't have access to transcoding, then force stream copy, regardless of whether it will be compatible or not
  1275. if (user != null && !user.Policy.EnableVideoPlaybackTranscoding)
  1276. {
  1277. state.OutputVideoCodec = "copy";
  1278. }
  1279. }
  1280. if (state.AudioStream != null && CanStreamCopyAudio(state, state.AudioStream, state.SupportedAudioCodecs))
  1281. {
  1282. state.OutputAudioCodec = "copy";
  1283. }
  1284. else
  1285. {
  1286. var user = state.User;
  1287. // If the user doesn't have access to transcoding, then force stream copy, regardless of whether it will be compatible or not
  1288. if (user != null && !user.Policy.EnableAudioPlaybackTranscoding)
  1289. {
  1290. state.OutputAudioCodec = "copy";
  1291. }
  1292. }
  1293. }
  1294. public static string GetProbeSizeArgument(int numInputFiles)
  1295. {
  1296. return numInputFiles > 1 ? "-probesize 1G" : "";
  1297. }
  1298. public static string GetAnalyzeDurationArgument(int numInputFiles)
  1299. {
  1300. return numInputFiles > 1 ? "-analyzeduration 200M" : "";
  1301. }
  1302. public string GetInputModifier(EncodingJobInfo state, EncodingOptions encodingOptions)
  1303. {
  1304. var inputModifier = string.Empty;
  1305. var numInputFiles = state.PlayableStreamFileNames.Length > 0 ? state.PlayableStreamFileNames.Length : 1;
  1306. var probeSizeArgument = GetProbeSizeArgument(numInputFiles);
  1307. string analyzeDurationArgument;
  1308. if (state.MediaSource.AnalyzeDurationMs.HasValue)
  1309. {
  1310. analyzeDurationArgument = "-analyzeduration " + (state.MediaSource.AnalyzeDurationMs.Value * 1000).ToString(CultureInfo.InvariantCulture);
  1311. }
  1312. else
  1313. {
  1314. analyzeDurationArgument = GetAnalyzeDurationArgument(numInputFiles);
  1315. }
  1316. if (!string.IsNullOrWhiteSpace(probeSizeArgument))
  1317. {
  1318. inputModifier += " " + probeSizeArgument;
  1319. }
  1320. if (!string.IsNullOrWhiteSpace(analyzeDurationArgument))
  1321. {
  1322. inputModifier += " " + analyzeDurationArgument;
  1323. }
  1324. inputModifier = inputModifier.Trim();
  1325. var userAgentParam = GetUserAgentParam(state);
  1326. if (!string.IsNullOrWhiteSpace(userAgentParam))
  1327. {
  1328. inputModifier += " " + userAgentParam;
  1329. }
  1330. inputModifier = inputModifier.Trim();
  1331. inputModifier += " " + GetFastSeekCommandLineParameter(state.BaseRequest);
  1332. inputModifier = inputModifier.Trim();
  1333. if (state.InputProtocol == MediaProtocol.Rtsp)
  1334. {
  1335. inputModifier += " -rtsp_transport tcp";
  1336. }
  1337. if (!string.IsNullOrEmpty(state.InputAudioSync))
  1338. {
  1339. inputModifier += " -async " + state.InputAudioSync;
  1340. }
  1341. if (!string.IsNullOrEmpty(state.InputVideoSync))
  1342. {
  1343. inputModifier += " -vsync " + state.InputVideoSync;
  1344. }
  1345. if (state.ReadInputAtNativeFramerate && state.InputProtocol != MediaProtocol.Rtsp)
  1346. {
  1347. inputModifier += " -re";
  1348. }
  1349. var flags = new List<string>();
  1350. if (state.IgnoreInputDts)
  1351. {
  1352. flags.Add("+igndts");
  1353. }
  1354. if (state.IgnoreInputIndex)
  1355. {
  1356. flags.Add("+ignidx");
  1357. }
  1358. if (state.GenPtsInput)
  1359. {
  1360. flags.Add("+genpts");
  1361. }
  1362. if (state.DiscardCorruptFramesInput)
  1363. {
  1364. flags.Add("+discardcorrupt");
  1365. }
  1366. if (state.EnableFastSeekInput)
  1367. {
  1368. flags.Add("+fastseek");
  1369. }
  1370. if (flags.Count > 0)
  1371. {
  1372. inputModifier += " -fflags " + string.Join("", flags.ToArray());
  1373. }
  1374. var videoDecoder = GetVideoDecoder(state, encodingOptions);
  1375. if (!string.IsNullOrWhiteSpace(videoDecoder))
  1376. {
  1377. inputModifier += " " + videoDecoder;
  1378. }
  1379. if (state.IsVideoRequest)
  1380. {
  1381. var outputVideoCodec = GetVideoEncoder(state, encodingOptions);
  1382. // Important: If this is ever re-enabled, make sure not to use it with wtv because it breaks seeking
  1383. if (!string.Equals(state.InputContainer, "wtv", StringComparison.OrdinalIgnoreCase) &&
  1384. state.TranscodingType != TranscodingJobType.Progressive &&
  1385. state.EnableBreakOnNonKeyFrames(outputVideoCodec))
  1386. {
  1387. inputModifier += " -noaccurate_seek";
  1388. }
  1389. if (!string.IsNullOrWhiteSpace(state.InputContainer) && state.VideoType == VideoType.VideoFile && string.IsNullOrWhiteSpace(encodingOptions.HardwareAccelerationType))
  1390. {
  1391. var inputFormat = GetInputFormat(state.InputContainer);
  1392. if (!string.IsNullOrWhiteSpace(inputFormat))
  1393. {
  1394. inputModifier += " -f " + inputFormat;
  1395. }
  1396. }
  1397. }
  1398. if (state.MediaSource.RequiresLooping)
  1399. {
  1400. inputModifier += " -stream_loop -1";
  1401. }
  1402. return inputModifier;
  1403. }
  1404. public void AttachMediaSourceInfo(EncodingJobInfo state,
  1405. MediaSourceInfo mediaSource,
  1406. string requestedUrl)
  1407. {
  1408. if (state == null)
  1409. {
  1410. throw new ArgumentNullException("state");
  1411. }
  1412. if (mediaSource == null)
  1413. {
  1414. throw new ArgumentNullException("mediaSource");
  1415. }
  1416. state.MediaPath = mediaSource.Path;
  1417. state.InputProtocol = mediaSource.Protocol;
  1418. state.InputContainer = mediaSource.Container;
  1419. state.RunTimeTicks = mediaSource.RunTimeTicks;
  1420. state.RemoteHttpHeaders = mediaSource.RequiredHttpHeaders;
  1421. state.IsoType = mediaSource.IsoType;
  1422. if (mediaSource.VideoType.HasValue)
  1423. {
  1424. state.VideoType = mediaSource.VideoType.Value;
  1425. if (mediaSource.VideoType.Value == VideoType.BluRay || mediaSource.VideoType.Value == VideoType.Dvd)
  1426. {
  1427. state.PlayableStreamFileNames = Video.QueryPlayableStreamFiles(state.MediaPath, mediaSource.VideoType.Value).Select(Path.GetFileName).ToArray();
  1428. }
  1429. else if (mediaSource.VideoType.Value == VideoType.Iso && state.IsoType == IsoType.BluRay)
  1430. {
  1431. state.PlayableStreamFileNames = Video.QueryPlayableStreamFiles(state.MediaPath, VideoType.BluRay).Select(Path.GetFileName).ToArray();
  1432. }
  1433. else if (mediaSource.VideoType.Value == VideoType.Iso && state.IsoType == IsoType.Dvd)
  1434. {
  1435. state.PlayableStreamFileNames = Video.QueryPlayableStreamFiles(state.MediaPath, VideoType.Dvd).Select(Path.GetFileName).ToArray();
  1436. }
  1437. else
  1438. {
  1439. state.PlayableStreamFileNames = new string[] { };
  1440. }
  1441. }
  1442. else
  1443. {
  1444. state.PlayableStreamFileNames = new string[] { };
  1445. }
  1446. if (mediaSource.Timestamp.HasValue)
  1447. {
  1448. state.InputTimestamp = mediaSource.Timestamp.Value;
  1449. }
  1450. state.InputProtocol = mediaSource.Protocol;
  1451. state.MediaPath = mediaSource.Path;
  1452. state.RunTimeTicks = mediaSource.RunTimeTicks;
  1453. state.RemoteHttpHeaders = mediaSource.RequiredHttpHeaders;
  1454. state.ReadInputAtNativeFramerate = mediaSource.ReadAtNativeFramerate;
  1455. if (state.ReadInputAtNativeFramerate ||
  1456. mediaSource.Protocol == MediaProtocol.File && string.Equals(mediaSource.Container, "wtv", StringComparison.OrdinalIgnoreCase))
  1457. {
  1458. state.InputVideoSync = "-1";
  1459. state.InputAudioSync = "1";
  1460. }
  1461. if (string.Equals(mediaSource.Container, "wma", StringComparison.OrdinalIgnoreCase) ||
  1462. string.Equals(mediaSource.Container, "asf", StringComparison.OrdinalIgnoreCase))
  1463. {
  1464. // Seeing some stuttering when transcoding wma to audio-only HLS
  1465. state.InputAudioSync = "1";
  1466. }
  1467. var mediaStreams = mediaSource.MediaStreams;
  1468. if (state.IsVideoRequest)
  1469. {
  1470. var videoRequest = state.BaseRequest;
  1471. if (string.IsNullOrEmpty(videoRequest.VideoCodec))
  1472. {
  1473. if (string.IsNullOrWhiteSpace(requestedUrl))
  1474. {
  1475. requestedUrl = "test." + videoRequest.OutputContainer;
  1476. }
  1477. videoRequest.VideoCodec = InferVideoCodec(requestedUrl);
  1478. }
  1479. state.VideoStream = GetMediaStream(mediaStreams, videoRequest.VideoStreamIndex, MediaStreamType.Video);
  1480. state.SubtitleStream = GetMediaStream(mediaStreams, videoRequest.SubtitleStreamIndex, MediaStreamType.Subtitle, false);
  1481. state.SubtitleDeliveryMethod = videoRequest.SubtitleMethod;
  1482. state.AudioStream = GetMediaStream(mediaStreams, videoRequest.AudioStreamIndex, MediaStreamType.Audio);
  1483. if (state.SubtitleStream != null && !state.SubtitleStream.IsExternal)
  1484. {
  1485. state.InternalSubtitleStreamOffset = mediaStreams.Where(i => i.Type == MediaStreamType.Subtitle && !i.IsExternal).ToList().IndexOf(state.SubtitleStream);
  1486. }
  1487. if (state.VideoStream != null && state.VideoStream.IsInterlaced)
  1488. {
  1489. state.DeInterlace = true;
  1490. }
  1491. EnforceResolutionLimit(state);
  1492. NormalizeSubtitleEmbed(state);
  1493. }
  1494. else
  1495. {
  1496. state.AudioStream = GetMediaStream(mediaStreams, null, MediaStreamType.Audio, true);
  1497. }
  1498. state.MediaSource = mediaSource;
  1499. }
  1500. private void NormalizeSubtitleEmbed(EncodingJobInfo state)
  1501. {
  1502. if (state.SubtitleStream == null || state.SubtitleDeliveryMethod != SubtitleDeliveryMethod.Embed)
  1503. {
  1504. return;
  1505. }
  1506. // This is tricky to remux in, after converting to dvdsub it's not positioned correctly
  1507. // Therefore, let's just burn it in
  1508. if (string.Equals(state.SubtitleStream.Codec, "DVBSUB", StringComparison.OrdinalIgnoreCase))
  1509. {
  1510. state.SubtitleDeliveryMethod = SubtitleDeliveryMethod.Encode;
  1511. }
  1512. }
  1513. /// <summary>
  1514. /// Gets the name of the output video codec
  1515. /// </summary>
  1516. protected string GetVideoDecoder(EncodingJobInfo state, EncodingOptions encodingOptions)
  1517. {
  1518. if (string.Equals(state.OutputVideoCodec, "copy", StringComparison.OrdinalIgnoreCase))
  1519. {
  1520. return null;
  1521. }
  1522. return GetVideoDecoder(state.MediaSource.VideoType ?? VideoType.VideoFile, state.VideoStream, encodingOptions);
  1523. }
  1524. public string GetVideoDecoder(VideoType videoType, MediaStream videoStream, EncodingOptions encodingOptions)
  1525. {
  1526. // Only use alternative encoders for video files.
  1527. // When using concat with folder rips, if the mfx session fails to initialize, ffmpeg will be stuck retrying and will not exit gracefully
  1528. // Since transcoding of folder rips is expiremental anyway, it's not worth adding additional variables such as this.
  1529. if (videoType != VideoType.VideoFile)
  1530. {
  1531. return null;
  1532. }
  1533. if (videoStream != null &&
  1534. !string.IsNullOrWhiteSpace(videoStream.Codec) &&
  1535. !string.IsNullOrWhiteSpace(encodingOptions.HardwareAccelerationType))
  1536. {
  1537. if (string.Equals(encodingOptions.HardwareAccelerationType, "qsv", StringComparison.OrdinalIgnoreCase))
  1538. {
  1539. switch (videoStream.Codec.ToLower())
  1540. {
  1541. case "avc":
  1542. case "h264":
  1543. if (_mediaEncoder.SupportsDecoder("h264_qsv") && encodingOptions.HardwareDecodingCodecs.Contains("h264", StringComparer.OrdinalIgnoreCase))
  1544. {
  1545. // qsv decoder does not support 10-bit input
  1546. if ((videoStream.BitDepth ?? 8) > 8)
  1547. {
  1548. return null;
  1549. }
  1550. return "-c:v h264_qsv ";
  1551. }
  1552. break;
  1553. case "hevc":
  1554. case "h265":
  1555. if (_mediaEncoder.SupportsDecoder("hevc_qsv") && encodingOptions.HardwareDecodingCodecs.Contains("hevc", StringComparer.OrdinalIgnoreCase))
  1556. {
  1557. return "-c:v hevc_qsv ";
  1558. }
  1559. break;
  1560. case "mpeg2video":
  1561. if (_mediaEncoder.SupportsDecoder("mpeg2_qsv") && encodingOptions.HardwareDecodingCodecs.Contains("mpeg2video", StringComparer.OrdinalIgnoreCase))
  1562. {
  1563. return "-c:v mpeg2_qsv ";
  1564. }
  1565. break;
  1566. case "vc1":
  1567. if (_mediaEncoder.SupportsDecoder("vc1_qsv") && encodingOptions.HardwareDecodingCodecs.Contains("vc1", StringComparer.OrdinalIgnoreCase))
  1568. {
  1569. return "-c:v vc1_qsv ";
  1570. }
  1571. break;
  1572. }
  1573. }
  1574. else if (string.Equals(encodingOptions.HardwareAccelerationType, "nvenc", StringComparison.OrdinalIgnoreCase))
  1575. {
  1576. switch (videoStream.Codec.ToLower())
  1577. {
  1578. case "avc":
  1579. case "h264":
  1580. if (_mediaEncoder.SupportsDecoder("h264_cuvid") && encodingOptions.HardwareDecodingCodecs.Contains("h264", StringComparer.OrdinalIgnoreCase))
  1581. {
  1582. return "-c:v h264_cuvid ";
  1583. }
  1584. break;
  1585. case "hevc":
  1586. case "h265":
  1587. if (_mediaEncoder.SupportsDecoder("hevc_cuvid") && encodingOptions.HardwareDecodingCodecs.Contains("hevc", StringComparer.OrdinalIgnoreCase))
  1588. {
  1589. return "-c:v hevc_cuvid ";
  1590. }
  1591. break;
  1592. case "mpeg2video":
  1593. if (_mediaEncoder.SupportsDecoder("mpeg2_cuvid") && encodingOptions.HardwareDecodingCodecs.Contains("mpeg2video", StringComparer.OrdinalIgnoreCase))
  1594. {
  1595. return "-c:v mpeg2_cuvid ";
  1596. }
  1597. break;
  1598. case "vc1":
  1599. if (_mediaEncoder.SupportsDecoder("vc1_cuvid") && encodingOptions.HardwareDecodingCodecs.Contains("vc1", StringComparer.OrdinalIgnoreCase))
  1600. {
  1601. return "-c:v vc1_cuvid ";
  1602. }
  1603. break;
  1604. case "mpeg4":
  1605. if (_mediaEncoder.SupportsDecoder("mpeg4_cuvid") && encodingOptions.HardwareDecodingCodecs.Contains("mpeg4", StringComparer.OrdinalIgnoreCase))
  1606. {
  1607. return "-c:v mpeg4_cuvid ";
  1608. }
  1609. break;
  1610. }
  1611. }
  1612. else if (string.Equals(encodingOptions.HardwareAccelerationType, "omx", StringComparison.OrdinalIgnoreCase))
  1613. {
  1614. switch (videoStream.Codec.ToLower())
  1615. {
  1616. case "avc":
  1617. case "h264":
  1618. if (_mediaEncoder.SupportsDecoder("h264_omx") && encodingOptions.HardwareDecodingCodecs.Contains("h264", StringComparer.OrdinalIgnoreCase))
  1619. {
  1620. return "-c:v h264_omx ";
  1621. }
  1622. break;
  1623. }
  1624. }
  1625. }
  1626. // leave blank so ffmpeg will decide
  1627. return null;
  1628. }
  1629. /// <summary>
  1630. /// Gets the number of threads.
  1631. /// </summary>
  1632. /// <returns>System.Int32.</returns>
  1633. private int GetNumberOfThreadsInternal(EncodingJobInfo state, EncodingOptions encodingOptions, bool isWebm)
  1634. {
  1635. var threads = encodingOptions.EncodingThreadCount;
  1636. if (isWebm)
  1637. {
  1638. // Recommended per docs
  1639. return Math.Max(Environment.ProcessorCount - 1, 2);
  1640. }
  1641. // Automatic
  1642. if (threads == -1)
  1643. {
  1644. return 0;
  1645. }
  1646. return threads;
  1647. }
  1648. public string GetSubtitleEmbedArguments(EncodingJobInfo state)
  1649. {
  1650. if (state.SubtitleStream == null || state.SubtitleDeliveryMethod != SubtitleDeliveryMethod.Embed)
  1651. {
  1652. return string.Empty;
  1653. }
  1654. var format = state.SupportedSubtitleCodecs.FirstOrDefault();
  1655. string codec;
  1656. if (string.IsNullOrWhiteSpace(format) || string.Equals(format, state.SubtitleStream.Codec, StringComparison.OrdinalIgnoreCase))
  1657. {
  1658. codec = "copy";
  1659. }
  1660. else
  1661. {
  1662. codec = format;
  1663. }
  1664. var args = " -codec:s:0 " + codec;
  1665. args += " -disposition:s:0 default";
  1666. return args;
  1667. }
  1668. public string GetProgressiveVideoFullCommandLine(EncodingJobInfo state, EncodingOptions encodingOptions, string outputPath, string defaultH264Preset)
  1669. {
  1670. // Get the output codec name
  1671. var videoCodec = GetVideoEncoder(state, encodingOptions);
  1672. var format = string.Empty;
  1673. var keyFrame = string.Empty;
  1674. if (string.Equals(Path.GetExtension(outputPath), ".mp4", StringComparison.OrdinalIgnoreCase) &&
  1675. state.BaseRequest.Context == EncodingContext.Streaming)
  1676. {
  1677. // Comparison: https://github.com/jansmolders86/mediacenterjs/blob/master/lib/transcoding/desktop.js
  1678. format = " -f mp4 -movflags frag_keyframe+empty_moov";
  1679. }
  1680. var threads = GetNumberOfThreads(state, encodingOptions, string.Equals(videoCodec, "libvpx", StringComparison.OrdinalIgnoreCase));
  1681. var inputModifier = GetInputModifier(state, encodingOptions);
  1682. return string.Format("{0} {1}{2} {3} {4} -map_metadata -1 -map_chapters -1 -threads {5} {6}{7}{8} -y \"{9}\"",
  1683. inputModifier,
  1684. GetInputArgument(state, encodingOptions),
  1685. keyFrame,
  1686. GetMapArgs(state),
  1687. GetProgressiveVideoArguments(state, encodingOptions, videoCodec, defaultH264Preset),
  1688. threads,
  1689. GetProgressiveVideoAudioArguments(state, encodingOptions),
  1690. GetSubtitleEmbedArguments(state),
  1691. format,
  1692. outputPath
  1693. ).Trim();
  1694. }
  1695. public string GetOutputFFlags(EncodingJobInfo state)
  1696. {
  1697. var flags = new List<string>();
  1698. if (state.GenPtsOutput)
  1699. {
  1700. flags.Add("+genpts");
  1701. }
  1702. if (flags.Count > 0)
  1703. {
  1704. return " -fflags " + string.Join("", flags.ToArray());
  1705. }
  1706. return string.Empty;
  1707. }
  1708. public string GetProgressiveVideoArguments(EncodingJobInfo state, EncodingOptions encodingOptions, string videoCodec, string defaultH264Preset)
  1709. {
  1710. var args = "-codec:v:0 " + videoCodec;
  1711. if (state.EnableMpegtsM2TsMode)
  1712. {
  1713. args += " -mpegts_m2ts_mode 1";
  1714. }
  1715. if (string.Equals(videoCodec, "copy", StringComparison.OrdinalIgnoreCase))
  1716. {
  1717. if (state.VideoStream != null && IsH264(state.VideoStream) &&
  1718. string.Equals(state.OutputContainer, "ts", StringComparison.OrdinalIgnoreCase) &&
  1719. !string.Equals(state.VideoStream.NalLengthSize, "0", StringComparison.OrdinalIgnoreCase))
  1720. {
  1721. args += " -bsf:v h264_mp4toannexb";
  1722. }
  1723. if (state.RunTimeTicks.HasValue && state.BaseRequest.CopyTimestamps)
  1724. {
  1725. args += " -copyts -avoid_negative_ts disabled -start_at_zero";
  1726. }
  1727. if (!state.RunTimeTicks.HasValue)
  1728. {
  1729. args += " -flags -global_header -fflags +genpts";
  1730. }
  1731. }
  1732. else
  1733. {
  1734. var keyFrameArg = string.Format(" -force_key_frames \"expr:gte(t,n_forced*{0})\"",
  1735. 5.ToString(_usCulture));
  1736. args += keyFrameArg;
  1737. var hasGraphicalSubs = state.SubtitleStream != null && !state.SubtitleStream.IsTextSubtitleStream && state.SubtitleDeliveryMethod == SubtitleDeliveryMethod.Encode;
  1738. var hasCopyTs = false;
  1739. // Add resolution params, if specified
  1740. if (!hasGraphicalSubs)
  1741. {
  1742. var outputSizeParam = GetOutputSizeParam(state, videoCodec);
  1743. args += outputSizeParam;
  1744. hasCopyTs = outputSizeParam.IndexOf("copyts", StringComparison.OrdinalIgnoreCase) != -1;
  1745. }
  1746. if (state.RunTimeTicks.HasValue && state.BaseRequest.CopyTimestamps)
  1747. {
  1748. if (!hasCopyTs)
  1749. {
  1750. args += " -copyts";
  1751. }
  1752. args += " -avoid_negative_ts disabled -start_at_zero";
  1753. }
  1754. var qualityParam = GetVideoQualityParam(state, videoCodec, encodingOptions, defaultH264Preset);
  1755. if (!string.IsNullOrEmpty(qualityParam))
  1756. {
  1757. args += " " + qualityParam.Trim();
  1758. }
  1759. // This is for internal graphical subs
  1760. if (hasGraphicalSubs)
  1761. {
  1762. args += GetGraphicalSubtitleParam(state, videoCodec);
  1763. }
  1764. if (!state.RunTimeTicks.HasValue)
  1765. {
  1766. args += " -flags -global_header";
  1767. }
  1768. }
  1769. if (!string.IsNullOrEmpty(state.OutputVideoSync))
  1770. {
  1771. args += " -vsync " + state.OutputVideoSync;
  1772. }
  1773. args += GetOutputFFlags(state);
  1774. return args;
  1775. }
  1776. public string GetProgressiveVideoAudioArguments(EncodingJobInfo state, EncodingOptions encodingOptions)
  1777. {
  1778. // If the video doesn't have an audio stream, return a default.
  1779. if (state.AudioStream == null && state.VideoStream != null)
  1780. {
  1781. return string.Empty;
  1782. }
  1783. // Get the output codec name
  1784. var codec = GetAudioEncoder(state);
  1785. var args = "-codec:a:0 " + codec;
  1786. if (string.Equals(codec, "copy", StringComparison.OrdinalIgnoreCase))
  1787. {
  1788. return args;
  1789. }
  1790. // Add the number of audio channels
  1791. var channels = state.OutputAudioChannels;
  1792. if (channels.HasValue)
  1793. {
  1794. args += " -ac " + channels.Value;
  1795. }
  1796. var bitrate = state.OutputAudioBitrate;
  1797. if (bitrate.HasValue)
  1798. {
  1799. args += " -ab " + bitrate.Value.ToString(_usCulture);
  1800. }
  1801. if (state.OutputAudioSampleRate.HasValue)
  1802. {
  1803. args += " -ar " + state.OutputAudioSampleRate.Value.ToString(_usCulture);
  1804. }
  1805. args += " " + GetAudioFilterParam(state, encodingOptions, false);
  1806. return args;
  1807. }
  1808. public string GetProgressiveAudioFullCommandLine(EncodingJobInfo state, EncodingOptions encodingOptions, string outputPath)
  1809. {
  1810. var audioTranscodeParams = new List<string>();
  1811. var bitrate = state.OutputAudioBitrate;
  1812. if (bitrate.HasValue)
  1813. {
  1814. audioTranscodeParams.Add("-ab " + bitrate.Value.ToString(_usCulture));
  1815. }
  1816. if (state.OutputAudioChannels.HasValue)
  1817. {
  1818. audioTranscodeParams.Add("-ac " + state.OutputAudioChannels.Value.ToString(_usCulture));
  1819. }
  1820. // opus will fail on 44100
  1821. if (!string.Equals(state.OutputAudioCodec, "opus", StringComparison.OrdinalIgnoreCase))
  1822. {
  1823. if (state.OutputAudioSampleRate.HasValue)
  1824. {
  1825. audioTranscodeParams.Add("-ar " + state.OutputAudioSampleRate.Value.ToString(_usCulture));
  1826. }
  1827. }
  1828. var albumCoverInput = string.Empty;
  1829. var mapArgs = string.Empty;
  1830. var metadata = string.Empty;
  1831. var vn = string.Empty;
  1832. var hasArt = !string.IsNullOrWhiteSpace(state.AlbumCoverPath);
  1833. hasArt = false;
  1834. if (hasArt)
  1835. {
  1836. albumCoverInput = " -i \"" + state.AlbumCoverPath + "\"";
  1837. mapArgs = " -map 0:a -map 1:v -c:1:v copy";
  1838. metadata = " -metadata:s:v title=\"Album cover\" -metadata:s:v comment=\"Cover(Front)\"";
  1839. }
  1840. else
  1841. {
  1842. vn = " -vn";
  1843. }
  1844. var threads = GetNumberOfThreads(state, encodingOptions, false);
  1845. var inputModifier = GetInputModifier(state, encodingOptions);
  1846. return string.Format("{0} {1}{7}{8} -threads {2}{3} {4} -id3v2_version 3 -write_id3v1 1{6} -y \"{5}\"",
  1847. inputModifier,
  1848. GetInputArgument(state, encodingOptions),
  1849. threads,
  1850. vn,
  1851. string.Join(" ", audioTranscodeParams.ToArray()),
  1852. outputPath,
  1853. metadata,
  1854. albumCoverInput,
  1855. mapArgs).Trim();
  1856. }
  1857. }
  1858. }