BaseHlsService.cs 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293
  1. using MediaBrowser.Controller.Configuration;
  2. using MediaBrowser.Controller.Devices;
  3. using MediaBrowser.Controller.Dlna;
  4. using MediaBrowser.Controller.Library;
  5. using MediaBrowser.Controller.MediaEncoding;
  6. using MediaBrowser.Model.Entities;
  7. using MediaBrowser.Model.Extensions;
  8. using MediaBrowser.Model.IO;
  9. using MediaBrowser.Model.Net;
  10. using MediaBrowser.Model.Serialization;
  11. using System;
  12. using System.Collections.Generic;
  13. using System.IO;
  14. using System.Text;
  15. using System.Threading;
  16. using System.Threading.Tasks;
  17. using CommonIO;
  18. namespace MediaBrowser.Api.Playback.Hls
  19. {
  20. /// <summary>
  21. /// Class BaseHlsService
  22. /// </summary>
  23. public abstract class BaseHlsService : BaseStreamingService
  24. {
  25. protected BaseHlsService(IServerConfigurationManager serverConfig, IUserManager userManager, ILibraryManager libraryManager, IIsoManager isoManager, IMediaEncoder mediaEncoder, IFileSystem fileSystem, IDlnaManager dlnaManager, ISubtitleEncoder subtitleEncoder, IDeviceManager deviceManager, IMediaSourceManager mediaSourceManager, IZipClient zipClient, IJsonSerializer jsonSerializer)
  26. : base(serverConfig, userManager, libraryManager, isoManager, mediaEncoder, fileSystem, dlnaManager, subtitleEncoder, deviceManager, mediaSourceManager, zipClient, jsonSerializer)
  27. {
  28. }
  29. /// <summary>
  30. /// Gets the audio arguments.
  31. /// </summary>
  32. /// <param name="state">The state.</param>
  33. /// <returns>System.String.</returns>
  34. protected abstract string GetAudioArguments(StreamState state);
  35. /// <summary>
  36. /// Gets the video arguments.
  37. /// </summary>
  38. /// <param name="state">The state.</param>
  39. /// <returns>System.String.</returns>
  40. protected abstract string GetVideoArguments(StreamState state);
  41. /// <summary>
  42. /// Gets the segment file extension.
  43. /// </summary>
  44. /// <param name="state">The state.</param>
  45. /// <returns>System.String.</returns>
  46. protected abstract string GetSegmentFileExtension(StreamState state);
  47. /// <summary>
  48. /// Gets the type of the transcoding job.
  49. /// </summary>
  50. /// <value>The type of the transcoding job.</value>
  51. protected override TranscodingJobType TranscodingJobType
  52. {
  53. get { return TranscodingJobType.Hls; }
  54. }
  55. /// <summary>
  56. /// Processes the request.
  57. /// </summary>
  58. /// <param name="request">The request.</param>
  59. /// <param name="isLive">if set to <c>true</c> [is live].</param>
  60. /// <returns>System.Object.</returns>
  61. protected async Task<object> ProcessRequest(StreamRequest request, bool isLive)
  62. {
  63. return await ProcessRequestAsync(request, isLive).ConfigureAwait(false);
  64. }
  65. /// <summary>
  66. /// Processes the request async.
  67. /// </summary>
  68. /// <param name="request">The request.</param>
  69. /// <param name="isLive">if set to <c>true</c> [is live].</param>
  70. /// <returns>Task{System.Object}.</returns>
  71. /// <exception cref="ArgumentException">A video bitrate is required
  72. /// or
  73. /// An audio bitrate is required</exception>
  74. private async Task<object> ProcessRequestAsync(StreamRequest request, bool isLive)
  75. {
  76. var cancellationTokenSource = new CancellationTokenSource();
  77. var state = await GetState(request, cancellationTokenSource.Token).ConfigureAwait(false);
  78. TranscodingJob job = null;
  79. var playlist = state.OutputFilePath;
  80. if (!FileSystem.FileExists(playlist))
  81. {
  82. await ApiEntryPoint.Instance.TranscodingStartLock.WaitAsync(cancellationTokenSource.Token).ConfigureAwait(false);
  83. try
  84. {
  85. if (!FileSystem.FileExists(playlist))
  86. {
  87. // If the playlist doesn't already exist, startup ffmpeg
  88. try
  89. {
  90. job = await StartFfMpeg(state, playlist, cancellationTokenSource).ConfigureAwait(false);
  91. job.IsLiveOutput = isLive;
  92. }
  93. catch
  94. {
  95. state.Dispose();
  96. throw;
  97. }
  98. var waitForSegments = state.SegmentLength >= 10 ? 2 : 3;
  99. await WaitForMinimumSegmentCount(playlist, waitForSegments, cancellationTokenSource.Token).ConfigureAwait(false);
  100. }
  101. }
  102. finally
  103. {
  104. ApiEntryPoint.Instance.TranscodingStartLock.Release();
  105. }
  106. }
  107. if (isLive)
  108. {
  109. job = job ?? ApiEntryPoint.Instance.OnTranscodeBeginRequest(playlist, TranscodingJobType);
  110. if (job != null)
  111. {
  112. ApiEntryPoint.Instance.OnTranscodeEndRequest(job);
  113. }
  114. return ResultFactory.GetResult(GetLivePlaylistText(playlist, state.SegmentLength), MimeTypes.GetMimeType("playlist.m3u8"), new Dictionary<string, string>());
  115. }
  116. var audioBitrate = state.OutputAudioBitrate ?? 0;
  117. var videoBitrate = state.OutputVideoBitrate ?? 0;
  118. var appendBaselineStream = false;
  119. var baselineStreamBitrate = 64000;
  120. var playlistText = GetMasterPlaylistFileText(playlist, videoBitrate + audioBitrate, appendBaselineStream, baselineStreamBitrate);
  121. job = job ?? ApiEntryPoint.Instance.OnTranscodeBeginRequest(playlist, TranscodingJobType);
  122. if (job != null)
  123. {
  124. ApiEntryPoint.Instance.OnTranscodeEndRequest(job);
  125. }
  126. return ResultFactory.GetResult(playlistText, MimeTypes.GetMimeType("playlist.m3u8"), new Dictionary<string, string>());
  127. }
  128. private string GetLivePlaylistText(string path, int segmentLength)
  129. {
  130. using (var stream = FileSystem.GetFileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
  131. {
  132. using (var reader = new StreamReader(stream))
  133. {
  134. var text = reader.ReadToEnd();
  135. var newDuration = "#EXT-X-TARGETDURATION:" + segmentLength.ToString(UsCulture);
  136. // ffmpeg pads the reported length by a full second
  137. text = text.Replace("#EXT-X-TARGETDURATION:" + (segmentLength + 1).ToString(UsCulture), newDuration, StringComparison.OrdinalIgnoreCase);
  138. return text;
  139. }
  140. }
  141. }
  142. private string GetMasterPlaylistFileText(string firstPlaylist, int bitrate, bool includeBaselineStream, int baselineStreamBitrate)
  143. {
  144. var builder = new StringBuilder();
  145. builder.AppendLine("#EXTM3U");
  146. // Pad a little to satisfy the apple hls validator
  147. var paddedBitrate = Convert.ToInt32(bitrate * 1.15);
  148. // Main stream
  149. builder.AppendLine("#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=" + paddedBitrate.ToString(UsCulture));
  150. var playlistUrl = "hls/" + Path.GetFileName(firstPlaylist).Replace(".m3u8", "/stream.m3u8");
  151. builder.AppendLine(playlistUrl);
  152. // Low bitrate stream
  153. if (includeBaselineStream)
  154. {
  155. builder.AppendLine("#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=" + baselineStreamBitrate.ToString(UsCulture));
  156. playlistUrl = "hls/" + Path.GetFileName(firstPlaylist).Replace(".m3u8", "-low/stream.m3u8");
  157. builder.AppendLine(playlistUrl);
  158. }
  159. return builder.ToString();
  160. }
  161. protected virtual async Task WaitForMinimumSegmentCount(string playlist, int segmentCount, CancellationToken cancellationToken)
  162. {
  163. Logger.Debug("Waiting for {0} segments in {1}", segmentCount, playlist);
  164. while (true)
  165. {
  166. // Need to use FileShare.ReadWrite because we're reading the file at the same time it's being written
  167. using (var fileStream = GetPlaylistFileStream(playlist))
  168. {
  169. using (var reader = new StreamReader(fileStream))
  170. {
  171. var count = 0;
  172. while (!reader.EndOfStream)
  173. {
  174. var line = await reader.ReadLineAsync().ConfigureAwait(false);
  175. if (line.IndexOf("#EXTINF:", StringComparison.OrdinalIgnoreCase) != -1)
  176. {
  177. count++;
  178. if (count >= segmentCount)
  179. {
  180. Logger.Debug("Finished waiting for {0} segments in {1}", segmentCount, playlist);
  181. return;
  182. }
  183. }
  184. }
  185. await Task.Delay(100, cancellationToken).ConfigureAwait(false);
  186. }
  187. }
  188. }
  189. }
  190. protected Stream GetPlaylistFileStream(string path)
  191. {
  192. var tmpPath = path + ".tmp";
  193. try
  194. {
  195. return FileSystem.GetFileStream(tmpPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, true);
  196. }
  197. catch (IOException)
  198. {
  199. return FileSystem.GetFileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, true);
  200. }
  201. }
  202. protected override string GetCommandLineArguments(string outputPath, StreamState state, bool isEncoding)
  203. {
  204. var itsOffsetMs = 0;
  205. var itsOffset = itsOffsetMs == 0 ? string.Empty : string.Format("-itsoffset {0} ", TimeSpan.FromMilliseconds(itsOffsetMs).TotalSeconds.ToString(UsCulture));
  206. var threads = GetNumberOfThreads(state, false);
  207. var inputModifier = GetInputModifier(state);
  208. // If isEncoding is true we're actually starting ffmpeg
  209. var startNumberParam = isEncoding ? GetStartNumber(state).ToString(UsCulture) : "0";
  210. var baseUrlParam = string.Empty;
  211. if (state.Request is GetLiveHlsStream)
  212. {
  213. baseUrlParam = string.Format(" -hls_base_url \"{0}/\"",
  214. "hls/" + Path.GetFileNameWithoutExtension(outputPath));
  215. }
  216. var args = string.Format("{0} {1} {2} -map_metadata -1 -threads {3} {4} {5} -sc_threshold 0 {6} -hls_time {7} -start_number {8} -hls_list_size {9}{10} -y \"{11}\"",
  217. itsOffset,
  218. inputModifier,
  219. GetInputArgument(state),
  220. threads,
  221. GetMapArgs(state),
  222. GetVideoArguments(state),
  223. GetAudioArguments(state),
  224. state.SegmentLength.ToString(UsCulture),
  225. startNumberParam,
  226. state.HlsListSize.ToString(UsCulture),
  227. baseUrlParam,
  228. outputPath
  229. ).Trim();
  230. return args;
  231. }
  232. protected virtual int GetStartNumber(StreamState state)
  233. {
  234. return 0;
  235. }
  236. protected bool IsLiveStream(StreamState state)
  237. {
  238. var isLiveStream = (state.RunTimeTicks ?? 0) == 0;
  239. if (state.VideoRequest.ForceLiveStream)
  240. {
  241. return true;
  242. }
  243. return isLiveStream;
  244. }
  245. }
  246. }