jellyfin/Emby.Server.Implementations/LiveTv/EmbyTV/EncodedRecorder.cs

428 lines
15 KiB
C#
Raw Normal View History

2016-02-12 07:01:38 +00:00
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
2016-10-25 19:02:04 +00:00
using MediaBrowser.Model.IO;
2017-05-26 06:48:54 +00:00
using MediaBrowser.Common.Net;
using MediaBrowser.Controller;
2017-04-21 20:03:07 +00:00
using MediaBrowser.Controller.Configuration;
2016-02-12 07:01:38 +00:00
using MediaBrowser.Controller.MediaEncoding;
2017-04-21 20:03:07 +00:00
using MediaBrowser.Model.Configuration;
2016-11-03 23:35:19 +00:00
using MediaBrowser.Model.Diagnostics;
2016-02-12 07:01:38 +00:00
using MediaBrowser.Model.Dto;
using MediaBrowser.Model.Entities;
using MediaBrowser.Model.LiveTv;
2016-02-12 07:01:38 +00:00
using MediaBrowser.Model.Logging;
using MediaBrowser.Model.Serialization;
2017-04-21 20:03:07 +00:00
using MediaBrowser.Common.Configuration;
2017-05-15 19:45:39 +00:00
using MediaBrowser.Controller.Library;
2016-02-12 07:01:38 +00:00
2016-11-03 23:35:19 +00:00
namespace Emby.Server.Implementations.LiveTv.EmbyTV
2016-02-12 07:01:38 +00:00
{
public class EncodedRecorder : IRecorder
{
private readonly ILogger _logger;
private readonly IFileSystem _fileSystem;
private readonly IHttpClient _httpClient;
2016-02-12 07:01:38 +00:00
private readonly IMediaEncoder _mediaEncoder;
private readonly IServerApplicationPaths _appPaths;
private readonly LiveTvOptions _liveTvOptions;
2016-02-12 07:01:38 +00:00
private bool _hasExited;
2016-11-30 19:50:39 +00:00
private Stream _logFileStream;
2016-02-12 07:01:38 +00:00
private string _targetPath;
2016-11-03 23:35:19 +00:00
private IProcess _process;
private readonly IProcessFactory _processFactory;
2016-02-12 07:01:38 +00:00
private readonly IJsonSerializer _json;
2016-03-07 04:56:45 +00:00
private readonly TaskCompletionSource<bool> _taskCompletionSource = new TaskCompletionSource<bool>();
2017-04-21 20:03:07 +00:00
private readonly IServerConfigurationManager _config;
2016-02-12 07:01:38 +00:00
2017-04-21 20:03:07 +00:00
public EncodedRecorder(ILogger logger, IFileSystem fileSystem, IMediaEncoder mediaEncoder, IServerApplicationPaths appPaths, IJsonSerializer json, LiveTvOptions liveTvOptions, IHttpClient httpClient, IProcessFactory processFactory, IServerConfigurationManager config)
2016-02-12 07:01:38 +00:00
{
_logger = logger;
_fileSystem = fileSystem;
_mediaEncoder = mediaEncoder;
_appPaths = appPaths;
_json = json;
_liveTvOptions = liveTvOptions;
_httpClient = httpClient;
2016-11-03 23:35:19 +00:00
_processFactory = processFactory;
2017-04-21 20:03:07 +00:00
_config = config;
2016-02-12 07:01:38 +00:00
}
2016-09-08 06:41:49 +00:00
private string OutputFormat
{
get
{
var format = _liveTvOptions.RecordingEncodingFormat;
2016-11-05 17:39:12 +00:00
if (string.Equals(format, "mkv", StringComparison.OrdinalIgnoreCase))
2016-09-08 06:41:49 +00:00
{
return "mkv";
}
2017-05-15 19:45:39 +00:00
if (string.Equals(format, "ts", StringComparison.OrdinalIgnoreCase))
{
return "ts";
}
2016-09-08 06:41:49 +00:00
return "mkv";
2016-09-08 06:41:49 +00:00
}
}
2017-02-21 18:04:35 +00:00
private bool CopySubtitles
{
2017-02-22 20:58:02 +00:00
get
{
return false;
//return string.Equals(OutputFormat, "mkv", StringComparison.OrdinalIgnoreCase);
}
2017-02-21 18:04:35 +00:00
}
2016-05-10 05:15:06 +00:00
public string GetOutputPath(MediaSourceInfo mediaSource, string targetFile)
{
2017-05-02 12:53:21 +00:00
var extension = OutputFormat;
if (string.Equals(extension, "mpegts", StringComparison.OrdinalIgnoreCase))
{
extension = "ts";
}
return Path.ChangeExtension(targetFile, "." + extension);
2016-05-10 05:15:06 +00:00
}
2017-05-15 19:45:39 +00:00
public async Task Record(IDirectStreamProvider directStreamProvider, MediaSourceInfo mediaSource, string targetFile, TimeSpan duration, Action onStarted, CancellationToken cancellationToken)
2016-02-12 07:01:38 +00:00
{
2017-05-02 12:53:21 +00:00
//var durationToken = new CancellationTokenSource(duration);
//cancellationToken = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, durationToken.Token).Token;
2016-09-05 20:07:36 +00:00
2016-09-29 12:55:49 +00:00
await RecordFromFile(mediaSource, mediaSource.Path, targetFile, duration, onStarted, cancellationToken).ConfigureAwait(false);
2016-09-25 18:39:13 +00:00
_logger.Info("Recording completed to file {0}", targetFile);
}
2017-04-21 20:03:07 +00:00
private EncodingOptions GetEncodingOptions()
{
return _config.GetConfiguration<EncodingOptions>("encoding");
}
2016-09-29 12:55:49 +00:00
private Task RecordFromFile(MediaSourceInfo mediaSource, string inputFile, string targetFile, TimeSpan duration, Action onStarted, CancellationToken cancellationToken)
{
2016-02-12 07:01:38 +00:00
_targetPath = targetFile;
2017-05-04 18:14:45 +00:00
_fileSystem.CreateDirectory(_fileSystem.GetDirectoryName(targetFile));
2016-02-12 07:01:38 +00:00
2016-11-03 23:35:19 +00:00
var process = _processFactory.Create(new ProcessOptions
2016-02-12 07:01:38 +00:00
{
2016-11-03 23:35:19 +00:00
CreateNoWindow = true,
2016-11-30 19:50:39 +00:00
UseShellExecute = false,
2016-02-12 07:01:38 +00:00
2016-11-03 23:35:19 +00:00
// Must consume both stdout and stderr or deadlocks may occur
//RedirectStandardOutput = true,
2016-11-30 19:50:39 +00:00
RedirectStandardError = true,
RedirectStandardInput = true,
2016-02-12 07:01:38 +00:00
2016-11-03 23:35:19 +00:00
FileName = _mediaEncoder.EncoderPath,
Arguments = GetCommandLineArgs(mediaSource, inputFile, targetFile, duration),
2016-02-12 07:01:38 +00:00
2016-11-03 23:35:19 +00:00
IsHidden = true,
ErrorDialog = false,
2016-11-30 19:50:39 +00:00
EnableRaisingEvents = true
2016-11-03 23:35:19 +00:00
});
2016-02-12 07:01:38 +00:00
_process = process;
var commandLineLogMessage = process.StartInfo.FileName + " " + process.StartInfo.Arguments;
_logger.Info(commandLineLogMessage);
2016-11-30 19:50:39 +00:00
var logFilePath = Path.Combine(_appPaths.LogDirectoryPath, "record-transcode-" + Guid.NewGuid() + ".txt");
2017-05-04 18:14:45 +00:00
_fileSystem.CreateDirectory(_fileSystem.GetDirectoryName(logFilePath));
2016-02-12 07:01:38 +00:00
2016-11-30 19:50:39 +00:00
// FFMpeg writes debug/error info to stderr. This is useful when debugging so let's put it in the log directory.
_logFileStream = _fileSystem.GetFileStream(logFilePath, FileOpenMode.Create, FileAccessMode.Write, FileShareMode.Read, true);
var commandLineLogMessageBytes = Encoding.UTF8.GetBytes(_json.SerializeToString(mediaSource) + Environment.NewLine + Environment.NewLine + commandLineLogMessage + Environment.NewLine + Environment.NewLine);
_logFileStream.Write(commandLineLogMessageBytes, 0, commandLineLogMessageBytes.Length);
2016-02-12 07:01:38 +00:00
2016-09-29 12:55:49 +00:00
process.Exited += (sender, args) => OnFfMpegProcessExited(process, inputFile);
2016-02-12 07:01:38 +00:00
process.Start();
cancellationToken.Register(Stop);
// MUST read both stdout and stderr asynchronously or a deadlock may occurr
2016-07-02 02:16:05 +00:00
//process.BeginOutputReadLine();
2016-02-12 07:01:38 +00:00
2016-02-29 16:25:21 +00:00
onStarted();
2016-11-30 19:50:39 +00:00
// Important - don't await the log task or we won't be able to kill ffmpeg when the user stops playback
StartStreamingLog(process.StandardError.BaseStream, _logFileStream);
2016-09-30 18:43:59 +00:00
_logger.Info("ffmpeg recording process started for {0}", _targetPath);
2016-06-22 04:40:11 +00:00
return _taskCompletionSource.Task;
2016-02-12 07:01:38 +00:00
}
2016-06-22 04:40:11 +00:00
private string GetCommandLineArgs(MediaSourceInfo mediaSource, string inputTempFile, string targetFile, TimeSpan duration)
2016-02-12 07:01:38 +00:00
{
string videoArgs;
if (EncodeVideo(mediaSource))
{
var maxBitrate = 25000000;
videoArgs = string.Format(
2016-09-30 18:43:59 +00:00
"-codec:v:0 libx264 -force_key_frames \"expr:gte(t,n_forced*5)\" {0} -pix_fmt yuv420p -preset superfast -crf 23 -b:v {1} -maxrate {1} -bufsize ({1}*2) -vsync -1 -profile:v high -level 41",
2016-02-12 07:01:38 +00:00
GetOutputSizeParam(),
maxBitrate.ToString(CultureInfo.InvariantCulture));
}
else
{
videoArgs = "-codec:v:0 copy";
}
2017-05-15 19:45:39 +00:00
videoArgs += " -fflags +genpts";
2016-06-22 04:40:11 +00:00
var durationParam = " -t " + _mediaEncoder.GetTimeParameter(duration.Ticks);
2017-04-21 20:03:07 +00:00
2017-05-02 12:53:21 +00:00
var flags = new List<string>();
if (mediaSource.IgnoreDts)
2017-04-21 20:03:07 +00:00
{
2017-05-02 12:53:21 +00:00
flags.Add("+igndts");
}
if (mediaSource.IgnoreIndex)
{
flags.Add("+ignidx");
2017-04-21 20:03:07 +00:00
}
2017-05-15 19:45:39 +00:00
if (mediaSource.GenPtsInput)
{
flags.Add("+genpts");
}
2017-04-21 20:03:07 +00:00
2017-05-21 07:25:49 +00:00
var inputModifier = "-async 1 -vsync -1";
2016-09-30 06:50:06 +00:00
2017-05-02 12:53:21 +00:00
if (flags.Count > 0)
{
2017-05-21 07:25:49 +00:00
inputModifier += " -fflags " + string.Join("", flags.ToArray());
2017-05-02 12:53:21 +00:00
}
2016-02-12 07:01:38 +00:00
2017-08-11 21:55:48 +00:00
var videoStream = mediaSource.VideoStream;
var videoDecoder = videoStream == null ? null : new EncodingHelper(_mediaEncoder, _fileSystem, null).GetVideoDecoder(VideoType.VideoFile, videoStream, GetEncodingOptions());
if (!string.IsNullOrWhiteSpace(videoDecoder))
2016-02-12 07:01:38 +00:00
{
2017-08-11 21:55:48 +00:00
inputModifier += " " + videoDecoder;
2016-09-30 06:50:06 +00:00
}
2017-05-02 12:53:21 +00:00
if (mediaSource.ReadAtNativeFramerate)
2016-09-30 06:50:06 +00:00
{
2017-05-21 07:25:49 +00:00
inputModifier += " -re";
}
if (mediaSource.RequiresLooping)
{
inputModifier += " -stream_loop -1";
2016-02-12 07:01:38 +00:00
}
2016-11-09 17:25:33 +00:00
var analyzeDurationSeconds = 5;
var analyzeDuration = " -analyzeduration " +
(analyzeDurationSeconds * 1000000).ToString(CultureInfo.InvariantCulture);
2017-05-21 07:25:49 +00:00
inputModifier += analyzeDuration;
2016-11-09 17:25:33 +00:00
2017-02-21 18:04:35 +00:00
var subtitleArgs = CopySubtitles ? " -codec:s copy" : " -sn";
//var outputParam = string.Equals(Path.GetExtension(targetFile), ".mp4", StringComparison.OrdinalIgnoreCase) ?
// " -f mp4 -movflags frag_keyframe+empty_moov" :
// string.Empty;
var outputParam = string.Empty;
2017-03-26 04:22:30 +00:00
2017-05-02 12:53:21 +00:00
var commandLineArgs = string.Format("-i \"{0}\"{5} {2} -map_metadata -1 -threads 0 {3}{4}{6} -y \"{1}\"",
inputTempFile,
targetFile,
videoArgs,
GetAudioArgs(mediaSource),
subtitleArgs,
durationParam,
outputParam);
2016-02-12 07:01:38 +00:00
2017-05-21 07:25:49 +00:00
return inputModifier + " " + commandLineArgs;
2016-02-12 07:01:38 +00:00
}
private string GetAudioArgs(MediaSourceInfo mediaSource)
{
var mediaStreams = mediaSource.MediaStreams ?? new List<MediaStream>();
2016-06-15 18:56:37 +00:00
var inputAudioCodec = mediaStreams.Where(i => i.Type == MediaStreamType.Audio).Select(i => i.Codec).FirstOrDefault() ?? string.Empty;
2016-09-08 06:41:49 +00:00
// do not copy aac because many players have difficulty with aac_latm
2016-06-15 18:56:37 +00:00
if (_liveTvOptions.EnableOriginalAudioWithEncodedRecordings && !string.Equals(inputAudioCodec, "aac", StringComparison.OrdinalIgnoreCase))
2016-02-12 07:01:38 +00:00
{
2017-03-01 20:29:42 +00:00
return "-codec:a:0 copy";
2016-02-12 07:01:38 +00:00
}
var audioChannels = 2;
var audioStream = mediaStreams.FirstOrDefault(i => i.Type == MediaStreamType.Audio);
if (audioStream != null)
{
audioChannels = audioStream.Channels ?? audioChannels;
}
2017-03-01 20:29:42 +00:00
return "-codec:a:0 aac -strict experimental -ab 320000";
2016-02-12 07:01:38 +00:00
}
private bool EncodeVideo(MediaSourceInfo mediaSource)
{
2016-10-28 19:56:54 +00:00
if (string.Equals(_liveTvOptions.RecordedVideoCodec, "copy", StringComparison.OrdinalIgnoreCase))
{
return false;
}
2016-02-12 07:01:38 +00:00
var mediaStreams = mediaSource.MediaStreams ?? new List<MediaStream>();
2016-02-12 18:12:59 +00:00
return !mediaStreams.Any(i => i.Type == MediaStreamType.Video && string.Equals(i.Codec, "h264", StringComparison.OrdinalIgnoreCase) && !i.IsInterlaced);
2016-02-12 07:01:38 +00:00
}
protected string GetOutputSizeParam()
{
var filters = new List<string>();
filters.Add("yadif=0:-1:0");
var output = string.Empty;
if (filters.Count > 0)
{
output += string.Format(" -vf \"{0}\"", string.Join(",", filters.ToArray()));
}
return output;
}
private void Stop()
{
if (!_hasExited)
{
try
{
2017-01-20 17:53:48 +00:00
_logger.Info("Stopping ffmpeg recording process for {0}", _targetPath);
2016-02-12 07:01:38 +00:00
2016-11-30 19:50:39 +00:00
//process.Kill();
_process.StandardInput.WriteLine("q");
2016-02-12 07:01:38 +00:00
}
catch (Exception ex)
{
2017-01-20 17:53:48 +00:00
_logger.ErrorException("Error stopping recording transcoding job for {0}", ex, _targetPath);
}
if (_hasExited)
{
return;
}
try
{
_logger.Info("Calling recording process.WaitForExit for {0}", _targetPath);
2017-02-17 21:11:13 +00:00
if (_process.WaitForExit(10000))
2017-01-20 17:53:48 +00:00
{
return;
}
}
catch (Exception ex)
{
_logger.ErrorException("Error waiting for recording process to exit for {0}", ex, _targetPath);
}
if (_hasExited)
{
return;
}
try
{
_logger.Info("Killing ffmpeg recording process for {0}", _targetPath);
_process.Kill();
}
catch (Exception ex)
{
_logger.ErrorException("Error killing recording transcoding job for {0}", ex, _targetPath);
2016-02-12 07:01:38 +00:00
}
}
}
/// <summary>
/// Processes the exited.
/// </summary>
2016-11-03 23:35:19 +00:00
private void OnFfMpegProcessExited(IProcess process, string inputFile)
2016-02-12 07:01:38 +00:00
{
_hasExited = true;
2016-11-30 19:50:39 +00:00
DisposeLogStream();
2016-02-12 07:01:38 +00:00
try
{
2016-11-30 19:50:39 +00:00
var exitCode = process.ExitCode;
2016-03-07 04:56:45 +00:00
_logger.Info("FFMpeg recording exited with code {0} for {1}", exitCode, _targetPath);
if (exitCode == 0)
{
_taskCompletionSource.TrySetResult(true);
}
else
{
_taskCompletionSource.TrySetException(new Exception(string.Format("Recording for {0} failed. Exit code {1}", _targetPath, exitCode)));
}
2016-02-12 07:01:38 +00:00
}
catch
{
2016-03-07 04:56:45 +00:00
_logger.Error("FFMpeg recording exited with an error for {0}.", _targetPath);
_taskCompletionSource.TrySetException(new Exception(string.Format("Recording for {0} failed", _targetPath)));
2016-02-12 07:01:38 +00:00
}
}
2016-11-30 19:50:39 +00:00
private void DisposeLogStream()
{
if (_logFileStream != null)
{
try
{
_logFileStream.Dispose();
}
catch (Exception ex)
{
_logger.ErrorException("Error disposing recording log stream", ex);
}
_logFileStream = null;
}
}
private async void StartStreamingLog(Stream source, Stream target)
{
try
{
using (var reader = new StreamReader(source))
{
while (!reader.EndOfStream)
{
var line = await reader.ReadLineAsync().ConfigureAwait(false);
var bytes = Encoding.UTF8.GetBytes(Environment.NewLine + line);
await target.WriteAsync(bytes, 0, bytes.Length).ConfigureAwait(false);
await target.FlushAsync().ConfigureAwait(false);
}
}
}
catch (ObjectDisposedException)
{
// Don't spam the log. This doesn't seem to throw in windows, but sometimes under linux
}
catch (Exception ex)
{
_logger.ErrorException("Error reading ffmpeg recording log", ex);
}
}
2016-02-12 07:01:38 +00:00
}
2016-08-07 20:13:30 +00:00
}