ApiEntryPoint.cs 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616
  1. using MediaBrowser.Api.Playback;
  2. using MediaBrowser.Common.Configuration;
  3. using MediaBrowser.Common.IO;
  4. using MediaBrowser.Controller.Configuration;
  5. using MediaBrowser.Controller.Plugins;
  6. using MediaBrowser.Controller.Session;
  7. using MediaBrowser.Model.Configuration;
  8. using MediaBrowser.Model.Logging;
  9. using MediaBrowser.Model.Session;
  10. using System;
  11. using System.Collections.Generic;
  12. using System.Diagnostics;
  13. using System.IO;
  14. using System.Linq;
  15. using System.Threading;
  16. using System.Threading.Tasks;
  17. namespace MediaBrowser.Api
  18. {
  19. /// <summary>
  20. /// Class ServerEntryPoint
  21. /// </summary>
  22. public class ApiEntryPoint : IServerEntryPoint
  23. {
  24. /// <summary>
  25. /// The instance
  26. /// </summary>
  27. public static ApiEntryPoint Instance;
  28. /// <summary>
  29. /// Gets or sets the logger.
  30. /// </summary>
  31. /// <value>The logger.</value>
  32. private ILogger Logger { get; set; }
  33. /// <summary>
  34. /// The application paths
  35. /// </summary>
  36. private readonly IServerConfigurationManager _config;
  37. private readonly ISessionManager _sessionManager;
  38. private readonly IFileSystem _fileSystem;
  39. public readonly SemaphoreSlim TranscodingStartLock = new SemaphoreSlim(1, 1);
  40. /// <summary>
  41. /// Initializes a new instance of the <see cref="ApiEntryPoint" /> class.
  42. /// </summary>
  43. /// <param name="logger">The logger.</param>
  44. /// <param name="sessionManager">The session manager.</param>
  45. /// <param name="config">The configuration.</param>
  46. public ApiEntryPoint(ILogger logger, ISessionManager sessionManager, IServerConfigurationManager config, IFileSystem fileSystem)
  47. {
  48. Logger = logger;
  49. _sessionManager = sessionManager;
  50. _config = config;
  51. _fileSystem = fileSystem;
  52. Instance = this;
  53. }
  54. /// <summary>
  55. /// Runs this instance.
  56. /// </summary>
  57. public void Run()
  58. {
  59. try
  60. {
  61. DeleteEncodedMediaCache();
  62. }
  63. catch (DirectoryNotFoundException)
  64. {
  65. // Don't clutter the log
  66. }
  67. catch (IOException ex)
  68. {
  69. Logger.ErrorException("Error deleting encoded media cache", ex);
  70. }
  71. }
  72. public EncodingOptions GetEncodingOptions()
  73. {
  74. return _config.GetConfiguration<EncodingOptions>("encoding");
  75. }
  76. /// <summary>
  77. /// Deletes the encoded media cache.
  78. /// </summary>
  79. private void DeleteEncodedMediaCache()
  80. {
  81. var path = _config.ApplicationPaths.TranscodingTempPath;
  82. foreach (var file in Directory.EnumerateFiles(path, "*", SearchOption.AllDirectories)
  83. .ToList())
  84. {
  85. _fileSystem.DeleteFile(file);
  86. }
  87. }
  88. /// <summary>
  89. /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
  90. /// </summary>
  91. public void Dispose()
  92. {
  93. Dispose(true);
  94. GC.SuppressFinalize(this);
  95. }
  96. /// <summary>
  97. /// Releases unmanaged and - optionally - managed resources.
  98. /// </summary>
  99. /// <param name="dispose"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
  100. protected virtual void Dispose(bool dispose)
  101. {
  102. var jobCount = _activeTranscodingJobs.Count;
  103. Parallel.ForEach(_activeTranscodingJobs.ToList(), j => KillTranscodingJob(j, path => true));
  104. // Try to allow for some time to kill the ffmpeg processes and delete the partial stream files
  105. if (jobCount > 0)
  106. {
  107. Thread.Sleep(1000);
  108. }
  109. }
  110. /// <summary>
  111. /// The active transcoding jobs
  112. /// </summary>
  113. private readonly List<TranscodingJob> _activeTranscodingJobs = new List<TranscodingJob>();
  114. /// <summary>
  115. /// Called when [transcode beginning].
  116. /// </summary>
  117. /// <param name="path">The path.</param>
  118. /// <param name="streamId">The stream identifier.</param>
  119. /// <param name="transcodingJobId">The transcoding job identifier.</param>
  120. /// <param name="type">The type.</param>
  121. /// <param name="process">The process.</param>
  122. /// <param name="deviceId">The device id.</param>
  123. /// <param name="state">The state.</param>
  124. /// <param name="cancellationTokenSource">The cancellation token source.</param>
  125. /// <returns>TranscodingJob.</returns>
  126. public TranscodingJob OnTranscodeBeginning(string path,
  127. string streamId,
  128. string transcodingJobId,
  129. TranscodingJobType type,
  130. Process process,
  131. string deviceId,
  132. StreamState state,
  133. CancellationTokenSource cancellationTokenSource)
  134. {
  135. lock (_activeTranscodingJobs)
  136. {
  137. var job = new TranscodingJob
  138. {
  139. Type = type,
  140. Path = path,
  141. Process = process,
  142. ActiveRequestCount = 1,
  143. DeviceId = deviceId,
  144. CancellationTokenSource = cancellationTokenSource,
  145. Id = transcodingJobId,
  146. StreamId = streamId
  147. };
  148. _activeTranscodingJobs.Add(job);
  149. ReportTranscodingProgress(job, state, null, null, null, null);
  150. return job;
  151. }
  152. }
  153. public void ReportTranscodingProgress(TranscodingJob job, StreamState state, TimeSpan? transcodingPosition, float? framerate, double? percentComplete, long? bytesTranscoded)
  154. {
  155. var ticks = transcodingPosition.HasValue ? transcodingPosition.Value.Ticks : (long?)null;
  156. if (job != null)
  157. {
  158. job.Framerate = framerate;
  159. job.CompletionPercentage = percentComplete;
  160. job.TranscodingPositionTicks = ticks;
  161. job.BytesTranscoded = bytesTranscoded;
  162. }
  163. var deviceId = state.Request.DeviceId;
  164. if (!string.IsNullOrWhiteSpace(deviceId))
  165. {
  166. var audioCodec = state.ActualOutputVideoCodec;
  167. var videoCodec = state.ActualOutputVideoCodec;
  168. _sessionManager.ReportTranscodingInfo(deviceId, new TranscodingInfo
  169. {
  170. Bitrate = state.TotalOutputBitrate,
  171. AudioCodec = audioCodec,
  172. VideoCodec = videoCodec,
  173. Container = state.OutputContainer,
  174. Framerate = framerate,
  175. CompletionPercentage = percentComplete,
  176. Width = state.OutputWidth,
  177. Height = state.OutputHeight,
  178. AudioChannels = state.OutputAudioChannels,
  179. IsAudioDirect = string.Equals(state.OutputAudioCodec, "copy", StringComparison.OrdinalIgnoreCase),
  180. IsVideoDirect = string.Equals(state.OutputVideoCodec, "copy", StringComparison.OrdinalIgnoreCase)
  181. });
  182. }
  183. }
  184. /// <summary>
  185. /// <summary>
  186. /// The progressive
  187. /// </summary>
  188. /// Called when [transcode failed to start].
  189. /// </summary>
  190. /// <param name="path">The path.</param>
  191. /// <param name="type">The type.</param>
  192. /// <param name="state">The state.</param>
  193. public void OnTranscodeFailedToStart(string path, TranscodingJobType type, StreamState state)
  194. {
  195. lock (_activeTranscodingJobs)
  196. {
  197. var job = _activeTranscodingJobs.First(j => j.Type == type && j.Path.Equals(path, StringComparison.OrdinalIgnoreCase));
  198. _activeTranscodingJobs.Remove(job);
  199. }
  200. if (!string.IsNullOrWhiteSpace(state.Request.DeviceId))
  201. {
  202. _sessionManager.ClearTranscodingInfo(state.Request.DeviceId);
  203. }
  204. }
  205. /// <summary>
  206. /// Determines whether [has active transcoding job] [the specified path].
  207. /// </summary>
  208. /// <param name="path">The path.</param>
  209. /// <param name="type">The type.</param>
  210. /// <returns><c>true</c> if [has active transcoding job] [the specified path]; otherwise, <c>false</c>.</returns>
  211. public bool HasActiveTranscodingJob(string path, TranscodingJobType type)
  212. {
  213. return GetTranscodingJob(path, type) != null;
  214. }
  215. public TranscodingJob GetTranscodingJob(string path, TranscodingJobType type)
  216. {
  217. lock (_activeTranscodingJobs)
  218. {
  219. return _activeTranscodingJobs.FirstOrDefault(j => j.Type == type && j.Path.Equals(path, StringComparison.OrdinalIgnoreCase));
  220. }
  221. }
  222. public TranscodingJob GetTranscodingJob(string id)
  223. {
  224. lock (_activeTranscodingJobs)
  225. {
  226. return _activeTranscodingJobs.FirstOrDefault(j => j.Id.Equals(id, StringComparison.OrdinalIgnoreCase));
  227. }
  228. }
  229. /// <summary>
  230. /// Called when [transcode begin request].
  231. /// </summary>
  232. /// <param name="path">The path.</param>
  233. /// <param name="type">The type.</param>
  234. public TranscodingJob OnTranscodeBeginRequest(string path, TranscodingJobType type)
  235. {
  236. lock (_activeTranscodingJobs)
  237. {
  238. var job = _activeTranscodingJobs.FirstOrDefault(j => j.Type == type && j.Path.Equals(path, StringComparison.OrdinalIgnoreCase));
  239. if (job == null)
  240. {
  241. return null;
  242. }
  243. job.ActiveRequestCount++;
  244. job.DisposeKillTimer();
  245. return job;
  246. }
  247. }
  248. public void OnTranscodeEndRequest(TranscodingJob job)
  249. {
  250. job.ActiveRequestCount--;
  251. if (job.ActiveRequestCount == 0)
  252. {
  253. if (job.Type == TranscodingJobType.Progressive)
  254. {
  255. const int timerDuration = 1000;
  256. if (job.KillTimer == null)
  257. {
  258. job.KillTimer = new Timer(OnTranscodeKillTimerStopped, job, timerDuration, Timeout.Infinite);
  259. }
  260. else
  261. {
  262. job.KillTimer.Change(timerDuration, Timeout.Infinite);
  263. }
  264. }
  265. }
  266. }
  267. /// <summary>
  268. /// Called when [transcode kill timer stopped].
  269. /// </summary>
  270. /// <param name="state">The state.</param>
  271. private void OnTranscodeKillTimerStopped(object state)
  272. {
  273. var job = (TranscodingJob)state;
  274. KillTranscodingJob(job, path => true);
  275. }
  276. /// <summary>
  277. /// Kills the single transcoding job.
  278. /// </summary>
  279. /// <param name="deviceId">The device id.</param>
  280. /// <param name="streamId">The stream identifier.</param>
  281. /// <param name="deleteFiles">The delete files.</param>
  282. /// <returns>Task.</returns>
  283. internal void KillTranscodingJobs(string deviceId, string streamId, Func<string, bool> deleteFiles)
  284. {
  285. if (string.IsNullOrEmpty(deviceId))
  286. {
  287. throw new ArgumentNullException("deviceId");
  288. }
  289. KillTranscodingJobs(j =>
  290. {
  291. if (string.Equals(deviceId, j.DeviceId, StringComparison.OrdinalIgnoreCase))
  292. {
  293. return string.IsNullOrWhiteSpace(streamId) || string.Equals(streamId, j.StreamId, StringComparison.OrdinalIgnoreCase);
  294. }
  295. return false;
  296. }, deleteFiles);
  297. }
  298. /// <summary>
  299. /// Kills the transcoding jobs.
  300. /// </summary>
  301. /// <param name="killJob">The kill job.</param>
  302. /// <param name="deleteFiles">The delete files.</param>
  303. /// <returns>Task.</returns>
  304. private void KillTranscodingJobs(Func<TranscodingJob, bool> killJob, Func<string, bool> deleteFiles)
  305. {
  306. var jobs = new List<TranscodingJob>();
  307. lock (_activeTranscodingJobs)
  308. {
  309. // This is really only needed for HLS.
  310. // Progressive streams can stop on their own reliably
  311. jobs.AddRange(_activeTranscodingJobs.Where(killJob));
  312. }
  313. if (jobs.Count == 0)
  314. {
  315. return;
  316. }
  317. foreach (var job in jobs)
  318. {
  319. KillTranscodingJob(job, deleteFiles);
  320. }
  321. }
  322. /// <summary>
  323. /// Kills the transcoding job.
  324. /// </summary>
  325. /// <param name="job">The job.</param>
  326. /// <param name="delete">The delete.</param>
  327. private void KillTranscodingJob(TranscodingJob job, Func<string, bool> delete)
  328. {
  329. lock (_activeTranscodingJobs)
  330. {
  331. _activeTranscodingJobs.Remove(job);
  332. if (!job.CancellationTokenSource.IsCancellationRequested)
  333. {
  334. job.CancellationTokenSource.Cancel();
  335. }
  336. job.DisposeKillTimer();
  337. }
  338. lock (job.ProcessLock)
  339. {
  340. var process = job.Process;
  341. var hasExited = true;
  342. try
  343. {
  344. hasExited = process.HasExited;
  345. }
  346. catch (Exception ex)
  347. {
  348. Logger.ErrorException("Error determining if ffmpeg process has exited for {0}", ex, job.Path);
  349. }
  350. if (!hasExited)
  351. {
  352. try
  353. {
  354. if (job.TranscodingThrottler != null)
  355. {
  356. job.TranscodingThrottler.Stop();
  357. }
  358. Logger.Info("Killing ffmpeg process for {0}", job.Path);
  359. //process.Kill();
  360. process.StandardInput.WriteLine("q");
  361. // Need to wait because killing is asynchronous
  362. process.WaitForExit(5000);
  363. }
  364. catch (Exception ex)
  365. {
  366. Logger.ErrorException("Error killing transcoding job for {0}", ex, job.Path);
  367. }
  368. }
  369. }
  370. if (delete(job.Path))
  371. {
  372. DeletePartialStreamFiles(job.Path, job.Type, 0, 1500);
  373. }
  374. }
  375. private async void DeletePartialStreamFiles(string path, TranscodingJobType jobType, int retryCount, int delayMs)
  376. {
  377. if (retryCount >= 10)
  378. {
  379. return;
  380. }
  381. Logger.Info("Deleting partial stream file(s) {0}", path);
  382. await Task.Delay(delayMs).ConfigureAwait(false);
  383. try
  384. {
  385. if (jobType == TranscodingJobType.Progressive)
  386. {
  387. DeleteProgressivePartialStreamFiles(path);
  388. }
  389. else
  390. {
  391. DeleteHlsPartialStreamFiles(path);
  392. }
  393. }
  394. catch (DirectoryNotFoundException)
  395. {
  396. }
  397. catch (FileNotFoundException)
  398. {
  399. }
  400. catch (IOException ex)
  401. {
  402. Logger.ErrorException("Error deleting partial stream file(s) {0}", ex, path);
  403. DeletePartialStreamFiles(path, jobType, retryCount + 1, 500);
  404. }
  405. catch (Exception ex)
  406. {
  407. Logger.ErrorException("Error deleting partial stream file(s) {0}", ex, path);
  408. }
  409. }
  410. /// <summary>
  411. /// Deletes the progressive partial stream files.
  412. /// </summary>
  413. /// <param name="outputFilePath">The output file path.</param>
  414. private void DeleteProgressivePartialStreamFiles(string outputFilePath)
  415. {
  416. _fileSystem.DeleteFile(outputFilePath);
  417. }
  418. /// <summary>
  419. /// Deletes the HLS partial stream files.
  420. /// </summary>
  421. /// <param name="outputFilePath">The output file path.</param>
  422. private void DeleteHlsPartialStreamFiles(string outputFilePath)
  423. {
  424. var directory = Path.GetDirectoryName(outputFilePath);
  425. var name = Path.GetFileNameWithoutExtension(outputFilePath);
  426. var filesToDelete = Directory.EnumerateFiles(directory)
  427. .Where(f => f.IndexOf(name, StringComparison.OrdinalIgnoreCase) != -1)
  428. .ToList();
  429. Exception e = null;
  430. foreach (var file in filesToDelete)
  431. {
  432. try
  433. {
  434. Logger.Info("Deleting HLS file {0}", file);
  435. _fileSystem.DeleteFile(file);
  436. }
  437. catch (DirectoryNotFoundException)
  438. {
  439. }
  440. catch (FileNotFoundException)
  441. {
  442. }
  443. catch (IOException ex)
  444. {
  445. e = ex;
  446. Logger.ErrorException("Error deleting HLS file {0}", ex, file);
  447. }
  448. }
  449. if (e != null)
  450. {
  451. throw e;
  452. }
  453. }
  454. }
  455. /// <summary>
  456. /// Class TranscodingJob
  457. /// </summary>
  458. public class TranscodingJob
  459. {
  460. /// <summary>
  461. /// Gets or sets the stream identifier.
  462. /// </summary>
  463. /// <value>The stream identifier.</value>
  464. public string StreamId { get; set; }
  465. /// <summary>
  466. /// Gets or sets the path.
  467. /// </summary>
  468. /// <value>The path.</value>
  469. public string Path { get; set; }
  470. /// <summary>
  471. /// Gets or sets the type.
  472. /// </summary>
  473. /// <value>The type.</value>
  474. public TranscodingJobType Type { get; set; }
  475. /// <summary>
  476. /// Gets or sets the process.
  477. /// </summary>
  478. /// <value>The process.</value>
  479. public Process Process { get; set; }
  480. /// <summary>
  481. /// Gets or sets the active request count.
  482. /// </summary>
  483. /// <value>The active request count.</value>
  484. public int ActiveRequestCount { get; set; }
  485. /// <summary>
  486. /// Gets or sets the kill timer.
  487. /// </summary>
  488. /// <value>The kill timer.</value>
  489. public Timer KillTimer { get; set; }
  490. public string DeviceId { get; set; }
  491. public CancellationTokenSource CancellationTokenSource { get; set; }
  492. public object ProcessLock = new object();
  493. public bool HasExited { get; set; }
  494. public string Id { get; set; }
  495. public float? Framerate { get; set; }
  496. public double? CompletionPercentage { get; set; }
  497. public long? BytesDownloaded { get; set; }
  498. public long? BytesTranscoded { get; set; }
  499. public long? TranscodingPositionTicks { get; set; }
  500. public long? DownloadPositionTicks { get; set; }
  501. public TranscodingThrottler TranscodingThrottler { get; set; }
  502. public void DisposeKillTimer()
  503. {
  504. if (KillTimer != null)
  505. {
  506. KillTimer.Dispose();
  507. KillTimer = null;
  508. }
  509. }
  510. }
  511. /// <summary>
  512. /// Enum TranscodingJobType
  513. /// </summary>
  514. public enum TranscodingJobType
  515. {
  516. /// <summary>
  517. /// The progressive
  518. /// </summary>
  519. Progressive,
  520. /// <summary>
  521. /// The HLS
  522. /// </summary>
  523. Hls,
  524. /// <summary>
  525. /// The dash
  526. /// </summary>
  527. Dash
  528. }
  529. }