DynamicHlsService.cs 36 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960
  1. using MediaBrowser.Common.Net;
  2. using MediaBrowser.Controller.Configuration;
  3. using MediaBrowser.Controller.Devices;
  4. using MediaBrowser.Controller.Dlna;
  5. using MediaBrowser.Controller.Library;
  6. using MediaBrowser.Controller.MediaEncoding;
  7. using MediaBrowser.Controller.Net;
  8. using MediaBrowser.Model.Dlna;
  9. using MediaBrowser.Model.Entities;
  10. using MediaBrowser.Model.Extensions;
  11. using MediaBrowser.Model.IO;
  12. using MediaBrowser.Model.Serialization;
  13. using System;
  14. using System.Collections.Generic;
  15. using System.Globalization;
  16. using System.IO;
  17. using System.Linq;
  18. using System.Text;
  19. using System.Threading;
  20. using System.Threading.Tasks;
  21. using MediaBrowser.Model.Services;
  22. using MimeTypes = MediaBrowser.Model.Net.MimeTypes;
  23. namespace MediaBrowser.Api.Playback.Hls
  24. {
  25. /// <summary>
  26. /// Options is needed for chromecast. Threw Head in there since it's related
  27. /// </summary>
  28. [Route("/Videos/{Id}/master.m3u8", "GET", Summary = "Gets a video stream using HTTP live streaming.")]
  29. [Route("/Videos/{Id}/master.m3u8", "HEAD", Summary = "Gets a video stream using HTTP live streaming.")]
  30. public class GetMasterHlsVideoPlaylist : VideoStreamRequest, IMasterHlsRequest
  31. {
  32. public bool EnableAdaptiveBitrateStreaming { get; set; }
  33. public GetMasterHlsVideoPlaylist()
  34. {
  35. EnableAdaptiveBitrateStreaming = true;
  36. }
  37. }
  38. [Route("/Audio/{Id}/master.m3u8", "GET", Summary = "Gets an audio stream using HTTP live streaming.")]
  39. [Route("/Audio/{Id}/master.m3u8", "HEAD", Summary = "Gets an audio stream using HTTP live streaming.")]
  40. public class GetMasterHlsAudioPlaylist : StreamRequest, IMasterHlsRequest
  41. {
  42. public bool EnableAdaptiveBitrateStreaming { get; set; }
  43. public GetMasterHlsAudioPlaylist()
  44. {
  45. EnableAdaptiveBitrateStreaming = true;
  46. }
  47. }
  48. public interface IMasterHlsRequest
  49. {
  50. bool EnableAdaptiveBitrateStreaming { get; set; }
  51. }
  52. [Route("/Videos/{Id}/main.m3u8", "GET", Summary = "Gets a video stream using HTTP live streaming.")]
  53. public class GetVariantHlsVideoPlaylist : VideoStreamRequest
  54. {
  55. }
  56. [Route("/Audio/{Id}/main.m3u8", "GET", Summary = "Gets an audio stream using HTTP live streaming.")]
  57. public class GetVariantHlsAudioPlaylist : StreamRequest
  58. {
  59. }
  60. [Route("/Videos/{Id}/hls1/{PlaylistId}/{SegmentId}.{SegmentContainer}", "GET")]
  61. public class GetHlsVideoSegment : VideoStreamRequest
  62. {
  63. public string PlaylistId { get; set; }
  64. /// <summary>
  65. /// Gets or sets the segment id.
  66. /// </summary>
  67. /// <value>The segment id.</value>
  68. public string SegmentId { get; set; }
  69. }
  70. [Route("/Audio/{Id}/hls1/{PlaylistId}/{SegmentId}.{SegmentContainer}", "GET")]
  71. public class GetHlsAudioSegment : StreamRequest
  72. {
  73. public string PlaylistId { get; set; }
  74. /// <summary>
  75. /// Gets or sets the segment id.
  76. /// </summary>
  77. /// <value>The segment id.</value>
  78. public string SegmentId { get; set; }
  79. }
  80. [Authenticated]
  81. public class DynamicHlsService : BaseHlsService
  82. {
  83. public DynamicHlsService(IServerConfigurationManager serverConfig, IUserManager userManager, ILibraryManager libraryManager, IIsoManager isoManager, IMediaEncoder mediaEncoder, IFileSystem fileSystem, IDlnaManager dlnaManager, ISubtitleEncoder subtitleEncoder, IDeviceManager deviceManager, IMediaSourceManager mediaSourceManager, IZipClient zipClient, IJsonSerializer jsonSerializer, IAuthorizationContext authorizationContext, INetworkManager networkManager) : base(serverConfig, userManager, libraryManager, isoManager, mediaEncoder, fileSystem, dlnaManager, subtitleEncoder, deviceManager, mediaSourceManager, zipClient, jsonSerializer, authorizationContext)
  84. {
  85. NetworkManager = networkManager;
  86. }
  87. protected INetworkManager NetworkManager { get; private set; }
  88. public Task<object> Get(GetMasterHlsVideoPlaylist request)
  89. {
  90. return GetMasterPlaylistInternal(request, "GET");
  91. }
  92. public Task<object> Head(GetMasterHlsVideoPlaylist request)
  93. {
  94. return GetMasterPlaylistInternal(request, "HEAD");
  95. }
  96. public Task<object> Get(GetMasterHlsAudioPlaylist request)
  97. {
  98. return GetMasterPlaylistInternal(request, "GET");
  99. }
  100. public Task<object> Head(GetMasterHlsAudioPlaylist request)
  101. {
  102. return GetMasterPlaylistInternal(request, "HEAD");
  103. }
  104. public Task<object> Get(GetVariantHlsVideoPlaylist request)
  105. {
  106. return GetVariantPlaylistInternal(request, true, "main");
  107. }
  108. public Task<object> Get(GetVariantHlsAudioPlaylist request)
  109. {
  110. return GetVariantPlaylistInternal(request, false, "main");
  111. }
  112. public Task<object> Get(GetHlsVideoSegment request)
  113. {
  114. return GetDynamicSegment(request, request.SegmentId);
  115. }
  116. public Task<object> Get(GetHlsAudioSegment request)
  117. {
  118. return GetDynamicSegment(request, request.SegmentId);
  119. }
  120. private async Task<object> GetDynamicSegment(StreamRequest request, string segmentId)
  121. {
  122. if ((request.StartTimeTicks ?? 0) > 0)
  123. {
  124. throw new ArgumentException("StartTimeTicks is not allowed.");
  125. }
  126. var cancellationTokenSource = new CancellationTokenSource();
  127. var cancellationToken = cancellationTokenSource.Token;
  128. var requestedIndex = int.Parse(segmentId, NumberStyles.Integer, UsCulture);
  129. var state = await GetState(request, cancellationToken).ConfigureAwait(false);
  130. var playlistPath = Path.ChangeExtension(state.OutputFilePath, ".m3u8");
  131. var segmentPath = GetSegmentPath(state, playlistPath, requestedIndex);
  132. var segmentExtension = GetSegmentFileExtension(state.Request);
  133. TranscodingJob job = null;
  134. if (FileSystem.FileExists(segmentPath))
  135. {
  136. job = ApiEntryPoint.Instance.OnTranscodeBeginRequest(playlistPath, TranscodingJobType);
  137. return await GetSegmentResult(state, playlistPath, segmentPath, segmentExtension, requestedIndex, job, cancellationToken).ConfigureAwait(false);
  138. }
  139. var transcodingLock = ApiEntryPoint.Instance.GetTranscodingLock(playlistPath);
  140. await transcodingLock.WaitAsync(cancellationTokenSource.Token).ConfigureAwait(false);
  141. var released = false;
  142. var startTranscoding = false;
  143. try
  144. {
  145. if (FileSystem.FileExists(segmentPath))
  146. {
  147. job = ApiEntryPoint.Instance.OnTranscodeBeginRequest(playlistPath, TranscodingJobType);
  148. transcodingLock.Release();
  149. released = true;
  150. return await GetSegmentResult(state, playlistPath, segmentPath, segmentExtension, requestedIndex, job, cancellationToken).ConfigureAwait(false);
  151. }
  152. else
  153. {
  154. var currentTranscodingIndex = GetCurrentTranscodingIndex(playlistPath, segmentExtension);
  155. var segmentGapRequiringTranscodingChange = 24 / state.SegmentLength;
  156. if (currentTranscodingIndex == null)
  157. {
  158. Logger.Debug("Starting transcoding because currentTranscodingIndex=null");
  159. startTranscoding = true;
  160. }
  161. else if (requestedIndex < currentTranscodingIndex.Value)
  162. {
  163. Logger.Debug("Starting transcoding because requestedIndex={0} and currentTranscodingIndex={1}", requestedIndex, currentTranscodingIndex);
  164. startTranscoding = true;
  165. }
  166. else if (requestedIndex - currentTranscodingIndex.Value > segmentGapRequiringTranscodingChange)
  167. {
  168. Logger.Debug("Starting transcoding because segmentGap is {0} and max allowed gap is {1}. requestedIndex={2}", requestedIndex - currentTranscodingIndex.Value, segmentGapRequiringTranscodingChange, requestedIndex);
  169. startTranscoding = true;
  170. }
  171. if (startTranscoding)
  172. {
  173. // If the playlist doesn't already exist, startup ffmpeg
  174. try
  175. {
  176. ApiEntryPoint.Instance.KillTranscodingJobs(request.DeviceId, request.PlaySessionId, p => false);
  177. if (currentTranscodingIndex.HasValue)
  178. {
  179. DeleteLastFile(playlistPath, segmentExtension, 0);
  180. }
  181. request.StartTimeTicks = GetStartPositionTicks(state, requestedIndex);
  182. job = await StartFfMpeg(state, playlistPath, cancellationTokenSource).ConfigureAwait(false);
  183. }
  184. catch
  185. {
  186. state.Dispose();
  187. throw;
  188. }
  189. //await WaitForMinimumSegmentCount(playlistPath, 1, cancellationTokenSource.Token).ConfigureAwait(false);
  190. }
  191. else
  192. {
  193. job = ApiEntryPoint.Instance.OnTranscodeBeginRequest(playlistPath, TranscodingJobType);
  194. if (job.TranscodingThrottler != null)
  195. {
  196. job.TranscodingThrottler.UnpauseTranscoding();
  197. }
  198. }
  199. }
  200. }
  201. finally
  202. {
  203. if (!released)
  204. {
  205. transcodingLock.Release();
  206. }
  207. }
  208. //Logger.Info("waiting for {0}", segmentPath);
  209. //while (!File.Exists(segmentPath))
  210. //{
  211. // await Task.Delay(50, cancellationToken).ConfigureAwait(false);
  212. //}
  213. Logger.Info("returning {0}", segmentPath);
  214. job = job ?? ApiEntryPoint.Instance.OnTranscodeBeginRequest(playlistPath, TranscodingJobType);
  215. return await GetSegmentResult(state, playlistPath, segmentPath, segmentExtension, requestedIndex, job, cancellationToken).ConfigureAwait(false);
  216. }
  217. private const int BufferSize = 81920;
  218. private long GetStartPositionTicks(StreamState state, int requestedIndex)
  219. {
  220. double startSeconds = 0;
  221. var lengths = GetSegmentLengths(state);
  222. if (requestedIndex >= lengths.Length)
  223. {
  224. var msg = string.Format("Invalid segment index requested: {0} - Segment count: {1}", requestedIndex, lengths.Length);
  225. throw new ArgumentException(msg);
  226. }
  227. for (var i = 0; i < requestedIndex; i++)
  228. {
  229. startSeconds += lengths[i];
  230. }
  231. var position = TimeSpan.FromSeconds(startSeconds).Ticks;
  232. return position;
  233. }
  234. private long GetEndPositionTicks(StreamState state, int requestedIndex)
  235. {
  236. double startSeconds = 0;
  237. var lengths = GetSegmentLengths(state);
  238. if (requestedIndex >= lengths.Length)
  239. {
  240. var msg = string.Format("Invalid segment index requested: {0} - Segment count: {1}", requestedIndex, lengths.Length);
  241. throw new ArgumentException(msg);
  242. }
  243. for (var i = 0; i <= requestedIndex; i++)
  244. {
  245. startSeconds += lengths[i];
  246. }
  247. var position = TimeSpan.FromSeconds(startSeconds).Ticks;
  248. return position;
  249. }
  250. private double[] GetSegmentLengths(StreamState state)
  251. {
  252. var result = new List<double>();
  253. var ticks = state.RunTimeTicks ?? 0;
  254. var segmentLengthTicks = TimeSpan.FromSeconds(state.SegmentLength).Ticks;
  255. while (ticks > 0)
  256. {
  257. var length = ticks >= segmentLengthTicks ? segmentLengthTicks : ticks;
  258. result.Add(TimeSpan.FromTicks(length).TotalSeconds);
  259. ticks -= length;
  260. }
  261. return result.ToArray();
  262. }
  263. public int? GetCurrentTranscodingIndex(string playlist, string segmentExtension)
  264. {
  265. var job = ApiEntryPoint.Instance.GetTranscodingJob(playlist, TranscodingJobType);
  266. if (job == null || job.HasExited)
  267. {
  268. return null;
  269. }
  270. var file = GetLastTranscodingFile(playlist, segmentExtension, FileSystem);
  271. if (file == null)
  272. {
  273. return null;
  274. }
  275. var playlistFilename = Path.GetFileNameWithoutExtension(playlist);
  276. var indexString = Path.GetFileNameWithoutExtension(file.Name).Substring(playlistFilename.Length);
  277. return int.Parse(indexString, NumberStyles.Integer, UsCulture);
  278. }
  279. private void DeleteLastFile(string playlistPath, string segmentExtension, int retryCount)
  280. {
  281. var file = GetLastTranscodingFile(playlistPath, segmentExtension, FileSystem);
  282. if (file != null)
  283. {
  284. DeleteFile(file.FullName, retryCount);
  285. }
  286. }
  287. private void DeleteFile(string path, int retryCount)
  288. {
  289. if (retryCount >= 5)
  290. {
  291. return;
  292. }
  293. Logger.Debug("Deleting partial HLS file {0}", path);
  294. try
  295. {
  296. FileSystem.DeleteFile(path);
  297. }
  298. catch (IOException ex)
  299. {
  300. Logger.ErrorException("Error deleting partial stream file(s) {0}", ex, path);
  301. var task = Task.Delay(100);
  302. Task.WaitAll(task);
  303. DeleteFile(path, retryCount + 1);
  304. }
  305. catch (Exception ex)
  306. {
  307. Logger.ErrorException("Error deleting partial stream file(s) {0}", ex, path);
  308. }
  309. }
  310. private static FileSystemMetadata GetLastTranscodingFile(string playlist, string segmentExtension, IFileSystem fileSystem)
  311. {
  312. var folder = fileSystem.GetDirectoryName(playlist);
  313. var filePrefix = Path.GetFileNameWithoutExtension(playlist) ?? string.Empty;
  314. try
  315. {
  316. return fileSystem.GetFiles(folder, new[] { segmentExtension }, true, false)
  317. .Where(i => Path.GetFileNameWithoutExtension(i.Name).StartsWith(filePrefix, StringComparison.OrdinalIgnoreCase))
  318. .OrderByDescending(fileSystem.GetLastWriteTimeUtc)
  319. .FirstOrDefault();
  320. }
  321. catch (IOException)
  322. {
  323. return null;
  324. }
  325. }
  326. protected override int GetStartNumber(StreamState state)
  327. {
  328. return GetStartNumber(state.VideoRequest);
  329. }
  330. private int GetStartNumber(VideoStreamRequest request)
  331. {
  332. var segmentId = "0";
  333. var segmentRequest = request as GetHlsVideoSegment;
  334. if (segmentRequest != null)
  335. {
  336. segmentId = segmentRequest.SegmentId;
  337. }
  338. return int.Parse(segmentId, NumberStyles.Integer, UsCulture);
  339. }
  340. private string GetSegmentPath(StreamState state, string playlist, int index)
  341. {
  342. var folder = FileSystem.GetDirectoryName(playlist);
  343. var filename = Path.GetFileNameWithoutExtension(playlist);
  344. return Path.Combine(folder, filename + index.ToString(UsCulture) + GetSegmentFileExtension(state.Request));
  345. }
  346. private async Task<object> GetSegmentResult(StreamState state,
  347. string playlistPath,
  348. string segmentPath,
  349. string segmentExtension,
  350. int segmentIndex,
  351. TranscodingJob transcodingJob,
  352. CancellationToken cancellationToken)
  353. {
  354. var segmentFileExists = FileSystem.FileExists(segmentPath);
  355. // If all transcoding has completed, just return immediately
  356. if (transcodingJob != null && transcodingJob.HasExited && segmentFileExists)
  357. {
  358. return await GetSegmentResult(state, segmentPath, segmentIndex, transcodingJob).ConfigureAwait(false);
  359. }
  360. if (segmentFileExists)
  361. {
  362. var currentTranscodingIndex = GetCurrentTranscodingIndex(playlistPath, segmentExtension);
  363. // If requested segment is less than transcoding position, we can't transcode backwards, so assume it's ready
  364. if (segmentIndex < currentTranscodingIndex)
  365. {
  366. return await GetSegmentResult(state, segmentPath, segmentIndex, transcodingJob).ConfigureAwait(false);
  367. }
  368. }
  369. var segmentFilename = Path.GetFileName(segmentPath);
  370. while (!cancellationToken.IsCancellationRequested)
  371. {
  372. try
  373. {
  374. var text = FileSystem.ReadAllText(playlistPath, Encoding.UTF8);
  375. // If it appears in the playlist, it's done
  376. if (text.IndexOf(segmentFilename, StringComparison.OrdinalIgnoreCase) != -1)
  377. {
  378. if (!segmentFileExists)
  379. {
  380. segmentFileExists = FileSystem.FileExists(segmentPath);
  381. }
  382. if (segmentFileExists)
  383. {
  384. return await GetSegmentResult(state, segmentPath, segmentIndex, transcodingJob).ConfigureAwait(false);
  385. }
  386. //break;
  387. }
  388. }
  389. catch (IOException)
  390. {
  391. // May get an error if the file is locked
  392. }
  393. await Task.Delay(100, cancellationToken).ConfigureAwait(false);
  394. }
  395. cancellationToken.ThrowIfCancellationRequested();
  396. return await GetSegmentResult(state, segmentPath, segmentIndex, transcodingJob).ConfigureAwait(false);
  397. }
  398. private Task<object> GetSegmentResult(StreamState state, string segmentPath, int index, TranscodingJob transcodingJob)
  399. {
  400. var segmentEndingPositionTicks = GetEndPositionTicks(state, index);
  401. return ResultFactory.GetStaticFileResult(Request, new StaticFileResultOptions
  402. {
  403. Path = segmentPath,
  404. FileShare = FileShareMode.ReadWrite,
  405. OnComplete = () =>
  406. {
  407. if (transcodingJob != null)
  408. {
  409. transcodingJob.DownloadPositionTicks = Math.Max(transcodingJob.DownloadPositionTicks ?? segmentEndingPositionTicks, segmentEndingPositionTicks);
  410. ApiEntryPoint.Instance.OnTranscodeEndRequest(transcodingJob);
  411. }
  412. }
  413. });
  414. }
  415. private async Task<object> GetMasterPlaylistInternal(StreamRequest request, string method)
  416. {
  417. var state = await GetState(request, CancellationToken.None).ConfigureAwait(false);
  418. if (string.IsNullOrEmpty(request.MediaSourceId))
  419. {
  420. throw new ArgumentException("MediaSourceId is required");
  421. }
  422. var playlistText = string.Empty;
  423. if (string.Equals(method, "GET", StringComparison.OrdinalIgnoreCase))
  424. {
  425. var audioBitrate = state.OutputAudioBitrate ?? 0;
  426. var videoBitrate = state.OutputVideoBitrate ?? 0;
  427. playlistText = GetMasterPlaylistFileText(state, videoBitrate + audioBitrate);
  428. }
  429. return ResultFactory.GetResult(playlistText, MimeTypes.GetMimeType("playlist.m3u8"), new Dictionary<string, string>());
  430. }
  431. private string GetMasterPlaylistFileText(StreamState state, int totalBitrate)
  432. {
  433. var builder = new StringBuilder();
  434. builder.AppendLine("#EXTM3U");
  435. var isLiveStream = state.IsSegmentedLiveStream;
  436. var queryStringIndex = Request.RawUrl.IndexOf('?');
  437. var queryString = queryStringIndex == -1 ? string.Empty : Request.RawUrl.Substring(queryStringIndex);
  438. // from universal audio service
  439. if (queryString.IndexOf("SegmentContainer", StringComparison.OrdinalIgnoreCase) == -1 && !string.IsNullOrWhiteSpace(state.Request.SegmentContainer))
  440. {
  441. queryString += "&SegmentContainer=" + state.Request.SegmentContainer;
  442. }
  443. // Main stream
  444. var playlistUrl = isLiveStream ? "live.m3u8" : "main.m3u8";
  445. playlistUrl += queryString;
  446. var request = state.Request;
  447. var subtitleStreams = state.MediaSource
  448. .MediaStreams
  449. .Where(i => i.IsTextSubtitleStream)
  450. .ToList();
  451. var subtitleGroup = subtitleStreams.Count > 0 &&
  452. request is GetMasterHlsVideoPlaylist &&
  453. (state.SubtitleDeliveryMethod == SubtitleDeliveryMethod.Hls || state.VideoRequest.EnableSubtitlesInManifest) ?
  454. "subs" :
  455. null;
  456. // If we're burning in subtitles then don't add additional subs to the manifest
  457. if (state.SubtitleStream != null && state.SubtitleDeliveryMethod == SubtitleDeliveryMethod.Encode)
  458. {
  459. subtitleGroup = null;
  460. }
  461. if (!string.IsNullOrWhiteSpace(subtitleGroup))
  462. {
  463. AddSubtitles(state, subtitleStreams, builder);
  464. }
  465. AppendPlaylist(builder, state, playlistUrl, totalBitrate, subtitleGroup);
  466. if (EnableAdaptiveBitrateStreaming(state, isLiveStream))
  467. {
  468. var requestedVideoBitrate = state.VideoRequest == null ? 0 : state.VideoRequest.VideoBitRate ?? 0;
  469. // By default, vary by just 200k
  470. var variation = GetBitrateVariation(totalBitrate);
  471. var newBitrate = totalBitrate - variation;
  472. var variantUrl = ReplaceBitrate(playlistUrl, requestedVideoBitrate, requestedVideoBitrate - variation);
  473. AppendPlaylist(builder, state, variantUrl, newBitrate, subtitleGroup);
  474. variation *= 2;
  475. newBitrate = totalBitrate - variation;
  476. variantUrl = ReplaceBitrate(playlistUrl, requestedVideoBitrate, requestedVideoBitrate - variation);
  477. AppendPlaylist(builder, state, variantUrl, newBitrate, subtitleGroup);
  478. }
  479. return builder.ToString();
  480. }
  481. private string ReplaceBitrate(string url, int oldValue, int newValue)
  482. {
  483. return url.Replace(
  484. "videobitrate=" + oldValue.ToString(UsCulture),
  485. "videobitrate=" + newValue.ToString(UsCulture),
  486. StringComparison.OrdinalIgnoreCase);
  487. }
  488. private void AddSubtitles(StreamState state, IEnumerable<MediaStream> subtitles, StringBuilder builder)
  489. {
  490. var selectedIndex = state.SubtitleStream == null || state.SubtitleDeliveryMethod != SubtitleDeliveryMethod.Hls ? (int?)null : state.SubtitleStream.Index;
  491. foreach (var stream in subtitles)
  492. {
  493. const string format = "#EXT-X-MEDIA:TYPE=SUBTITLES,GROUP-ID=\"subs\",NAME=\"{0}\",DEFAULT={1},FORCED={2},AUTOSELECT=YES,URI=\"{3}\",LANGUAGE=\"{4}\"";
  494. var name = stream.DisplayTitle;
  495. var isDefault = selectedIndex.HasValue && selectedIndex.Value == stream.Index;
  496. var isForced = stream.IsForced;
  497. var url = string.Format("{0}/Subtitles/{1}/subtitles.m3u8?SegmentLength={2}&api_key={3}",
  498. state.Request.MediaSourceId,
  499. stream.Index.ToString(UsCulture),
  500. 30.ToString(UsCulture),
  501. AuthorizationContext.GetAuthorizationInfo(Request).Token);
  502. var line = string.Format(format,
  503. name,
  504. isDefault ? "YES" : "NO",
  505. isForced ? "YES" : "NO",
  506. url,
  507. stream.Language ?? "Unknown");
  508. builder.AppendLine(line);
  509. }
  510. }
  511. private bool EnableAdaptiveBitrateStreaming(StreamState state, bool isLiveStream)
  512. {
  513. // Within the local network this will likely do more harm than good.
  514. if (Request.IsLocal || NetworkManager.IsInLocalNetwork(Request.RemoteIp))
  515. {
  516. return false;
  517. }
  518. var request = state.Request as IMasterHlsRequest;
  519. if (request != null && !request.EnableAdaptiveBitrateStreaming)
  520. {
  521. return false;
  522. }
  523. if (isLiveStream || string.IsNullOrWhiteSpace(state.MediaPath))
  524. {
  525. // Opening live streams is so slow it's not even worth it
  526. return false;
  527. }
  528. if (string.Equals(state.OutputVideoCodec, "copy", StringComparison.OrdinalIgnoreCase))
  529. {
  530. return false;
  531. }
  532. if (string.Equals(state.OutputAudioCodec, "copy", StringComparison.OrdinalIgnoreCase))
  533. {
  534. return false;
  535. }
  536. if (!state.IsOutputVideo)
  537. {
  538. return false;
  539. }
  540. // Having problems in android
  541. return false;
  542. //return state.VideoRequest.VideoBitRate.HasValue;
  543. }
  544. private void AppendPlaylist(StringBuilder builder, StreamState state, string url, int bitrate, string subtitleGroup)
  545. {
  546. var header = "#EXT-X-STREAM-INF:BANDWIDTH=" + bitrate.ToString(UsCulture) + ",AVERAGE-BANDWIDTH=" + bitrate.ToString(UsCulture);
  547. // tvos wants resolution, codecs, framerate
  548. //if (state.TargetFramerate.HasValue)
  549. //{
  550. // header += string.Format(",FRAME-RATE=\"{0}\"", state.TargetFramerate.Value.ToString(CultureInfo.InvariantCulture));
  551. //}
  552. if (!string.IsNullOrWhiteSpace(subtitleGroup))
  553. {
  554. header += string.Format(",SUBTITLES=\"{0}\"", subtitleGroup);
  555. }
  556. builder.AppendLine(header);
  557. builder.AppendLine(url);
  558. }
  559. private int GetBitrateVariation(int bitrate)
  560. {
  561. // By default, vary by just 50k
  562. var variation = 50000;
  563. if (bitrate >= 10000000)
  564. {
  565. variation = 2000000;
  566. }
  567. else if (bitrate >= 5000000)
  568. {
  569. variation = 1500000;
  570. }
  571. else if (bitrate >= 3000000)
  572. {
  573. variation = 1000000;
  574. }
  575. else if (bitrate >= 2000000)
  576. {
  577. variation = 500000;
  578. }
  579. else if (bitrate >= 1000000)
  580. {
  581. variation = 300000;
  582. }
  583. else if (bitrate >= 600000)
  584. {
  585. variation = 200000;
  586. }
  587. else if (bitrate >= 400000)
  588. {
  589. variation = 100000;
  590. }
  591. return variation;
  592. }
  593. private async Task<object> GetVariantPlaylistInternal(StreamRequest request, bool isOutputVideo, string name)
  594. {
  595. var state = await GetState(request, CancellationToken.None).ConfigureAwait(false);
  596. var segmentLengths = GetSegmentLengths(state);
  597. var builder = new StringBuilder();
  598. builder.AppendLine("#EXTM3U");
  599. builder.AppendLine("#EXT-X-PLAYLIST-TYPE:VOD");
  600. builder.AppendLine("#EXT-X-VERSION:3");
  601. builder.AppendLine("#EXT-X-TARGETDURATION:" + Math.Ceiling(segmentLengths.Length > 0 ? segmentLengths.Max() : state.SegmentLength).ToString(UsCulture));
  602. builder.AppendLine("#EXT-X-MEDIA-SEQUENCE:0");
  603. var queryStringIndex = Request.RawUrl.IndexOf('?');
  604. var queryString = queryStringIndex == -1 ? string.Empty : Request.RawUrl.Substring(queryStringIndex);
  605. //if ((Request.UserAgent ?? string.Empty).IndexOf("roku", StringComparison.OrdinalIgnoreCase) != -1)
  606. //{
  607. // queryString = string.Empty;
  608. //}
  609. var index = 0;
  610. foreach (var length in segmentLengths)
  611. {
  612. builder.AppendLine("#EXTINF:" + length.ToString("0.0000", UsCulture) + ", nodesc");
  613. builder.AppendLine(string.Format("hls1/{0}/{1}{2}{3}",
  614. name,
  615. index.ToString(UsCulture),
  616. GetSegmentFileExtension(request),
  617. queryString));
  618. index++;
  619. }
  620. builder.AppendLine("#EXT-X-ENDLIST");
  621. var playlistText = builder.ToString();
  622. return ResultFactory.GetResult(playlistText, MimeTypes.GetMimeType("playlist.m3u8"), new Dictionary<string, string>());
  623. }
  624. protected override string GetAudioArguments(StreamState state)
  625. {
  626. var codec = EncodingHelper.GetAudioEncoder(state);
  627. if (!state.IsOutputVideo)
  628. {
  629. if (string.Equals(codec, "copy", StringComparison.OrdinalIgnoreCase))
  630. {
  631. return "-acodec copy";
  632. }
  633. var audioTranscodeParams = new List<string>();
  634. audioTranscodeParams.Add("-acodec " + codec);
  635. if (state.OutputAudioBitrate.HasValue)
  636. {
  637. audioTranscodeParams.Add("-ab " + state.OutputAudioBitrate.Value.ToString(UsCulture));
  638. }
  639. if (state.OutputAudioChannels.HasValue)
  640. {
  641. audioTranscodeParams.Add("-ac " + state.OutputAudioChannels.Value.ToString(UsCulture));
  642. }
  643. if (state.OutputAudioSampleRate.HasValue)
  644. {
  645. audioTranscodeParams.Add("-ar " + state.OutputAudioSampleRate.Value.ToString(UsCulture));
  646. }
  647. audioTranscodeParams.Add("-vn");
  648. return string.Join(" ", audioTranscodeParams.ToArray());
  649. }
  650. if (string.Equals(codec, "copy", StringComparison.OrdinalIgnoreCase))
  651. {
  652. return "-codec:a:0 copy -copypriorss:a:0 0";
  653. }
  654. var args = "-codec:a:0 " + codec;
  655. var channels = state.OutputAudioChannels;
  656. if (channels.HasValue)
  657. {
  658. args += " -ac " + channels.Value;
  659. }
  660. var bitrate = state.OutputAudioBitrate;
  661. if (bitrate.HasValue)
  662. {
  663. args += " -ab " + bitrate.Value.ToString(UsCulture);
  664. }
  665. if (state.OutputAudioSampleRate.HasValue)
  666. {
  667. args += " -ar " + state.OutputAudioSampleRate.Value.ToString(UsCulture);
  668. }
  669. args += " " + EncodingHelper.GetAudioFilterParam(state, ApiEntryPoint.Instance.GetEncodingOptions(), true);
  670. return args;
  671. }
  672. protected override string GetVideoArguments(StreamState state)
  673. {
  674. if (!state.IsOutputVideo)
  675. {
  676. return string.Empty;
  677. }
  678. var codec = EncodingHelper.GetVideoEncoder(state, ApiEntryPoint.Instance.GetEncodingOptions());
  679. var args = "-codec:v:0 " + codec;
  680. if (state.EnableMpegtsM2TsMode)
  681. {
  682. args += " -mpegts_m2ts_mode 1";
  683. }
  684. // See if we can save come cpu cycles by avoiding encoding
  685. if (string.Equals(codec, "copy", StringComparison.OrdinalIgnoreCase))
  686. {
  687. if (state.VideoStream != null && EncodingHelper.IsH264(state.VideoStream) && !string.Equals(state.VideoStream.NalLengthSize, "0", StringComparison.OrdinalIgnoreCase))
  688. {
  689. args += " -bsf:v h264_mp4toannexb";
  690. }
  691. //args += " -flags -global_header";
  692. }
  693. else
  694. {
  695. var keyFrameArg = string.Format(" -force_key_frames \"expr:gte(t,n_forced*{0})\"",
  696. state.SegmentLength.ToString(UsCulture));
  697. var hasGraphicalSubs = state.SubtitleStream != null && !state.SubtitleStream.IsTextSubtitleStream && state.SubtitleDeliveryMethod == SubtitleDeliveryMethod.Encode;
  698. var encodingOptions = ApiEntryPoint.Instance.GetEncodingOptions();
  699. args += " " + EncodingHelper.GetVideoQualityParam(state, codec, encodingOptions, GetDefaultH264Preset()) + keyFrameArg;
  700. //args += " -mixed-refs 0 -refs 3 -x264opts b_pyramid=0:weightb=0:weightp=0";
  701. // Add resolution params, if specified
  702. if (!hasGraphicalSubs)
  703. {
  704. args += EncodingHelper.GetOutputSizeParam(state, codec, true);
  705. }
  706. // This is for internal graphical subs
  707. if (hasGraphicalSubs)
  708. {
  709. args += EncodingHelper.GetGraphicalSubtitleParam(state, codec);
  710. }
  711. //args += " -flags -global_header";
  712. }
  713. if (args.IndexOf("-copyts", StringComparison.OrdinalIgnoreCase) == -1)
  714. {
  715. args += " -copyts";
  716. }
  717. if (!string.IsNullOrEmpty(state.OutputVideoSync))
  718. {
  719. args += " -vsync " + state.OutputVideoSync;
  720. }
  721. args += EncodingHelper.GetOutputFFlags(state);
  722. return args;
  723. }
  724. protected override string GetCommandLineArguments(string outputPath, StreamState state, bool isEncoding)
  725. {
  726. var encodingOptions = ApiEntryPoint.Instance.GetEncodingOptions();
  727. var threads = EncodingHelper.GetNumberOfThreads(state, encodingOptions, false);
  728. var inputModifier = EncodingHelper.GetInputModifier(state, encodingOptions);
  729. // If isEncoding is true we're actually starting ffmpeg
  730. var startNumber = GetStartNumber(state);
  731. var startNumberParam = isEncoding ? startNumber.ToString(UsCulture) : "0";
  732. var mapArgs = state.IsOutputVideo ? EncodingHelper.GetMapArgs(state) : string.Empty;
  733. var outputTsArg = Path.Combine(FileSystem.GetDirectoryName(outputPath), Path.GetFileNameWithoutExtension(outputPath)) + "%d" + GetSegmentFileExtension(state.Request);
  734. var timeDeltaParam = String.Empty;
  735. if (isEncoding && startNumber > 0)
  736. {
  737. var startTime = state.SegmentLength * startNumber;
  738. timeDeltaParam = string.Format("-segment_time_delta -{0}", startTime);
  739. }
  740. var segmentFormat = GetSegmentFileExtension(state.Request).TrimStart('.');
  741. if (string.Equals(segmentFormat, "ts", StringComparison.OrdinalIgnoreCase))
  742. {
  743. segmentFormat = "mpegts";
  744. }
  745. var videoCodec = EncodingHelper.GetVideoEncoder(state, ApiEntryPoint.Instance.GetEncodingOptions());
  746. var breakOnNonKeyFrames = state.EnableBreakOnNonKeyFrames(videoCodec);
  747. var breakOnNonKeyFramesArg = breakOnNonKeyFrames ? " -break_non_keyframes 1" : "";
  748. return string.Format("{0} {1} -map_metadata -1 -map_chapters -1 -threads {2} {3} {4} {5} -f segment -max_delay 5000000 -avoid_negative_ts disabled -start_at_zero -segment_time {6} {10} -individual_header_trailer 0{12} -segment_format {11} -segment_list_type m3u8 -segment_start_number {7} -segment_list \"{8}\" -y \"{9}\"",
  749. inputModifier,
  750. EncodingHelper.GetInputArgument(state, encodingOptions),
  751. threads,
  752. mapArgs,
  753. GetVideoArguments(state),
  754. GetAudioArguments(state),
  755. state.SegmentLength.ToString(UsCulture),
  756. startNumberParam,
  757. outputPath,
  758. outputTsArg,
  759. timeDeltaParam,
  760. segmentFormat,
  761. breakOnNonKeyFramesArg
  762. ).Trim();
  763. }
  764. }
  765. }