2015-01-02 06:36:27 +01:00
using MediaBrowser.Controller.Channels ;
using MediaBrowser.Controller.Configuration ;
using MediaBrowser.Controller.Library ;
using MediaBrowser.Controller.LiveTv ;
2014-02-20 17:37:41 +01:00
using MediaBrowser.Controller.MediaEncoding ;
2015-01-02 06:36:27 +01:00
using MediaBrowser.Controller.Session ;
2015-04-04 21:35:29 +02:00
using MediaBrowser.MediaEncoding.Probing ;
2015-04-05 17:01:57 +02:00
using MediaBrowser.Model.Dlna ;
2015-09-08 22:40:48 +02:00
using MediaBrowser.Model.Dto ;
2013-04-07 22:55:05 +02:00
using MediaBrowser.Model.Entities ;
2015-01-02 06:36:27 +01:00
using MediaBrowser.Model.IO ;
2013-04-07 22:55:05 +02:00
using MediaBrowser.Model.Logging ;
2014-06-17 03:56:23 +02:00
using MediaBrowser.Model.MediaInfo ;
2013-04-07 22:55:05 +02:00
using MediaBrowser.Model.Serialization ;
using System ;
2015-04-10 21:08:09 +02:00
using System.Collections.Generic ;
2013-04-07 22:55:05 +02:00
using System.Diagnostics ;
2013-08-15 17:25:51 +02:00
using System.Globalization ;
2013-04-07 22:55:05 +02:00
using System.IO ;
2014-03-30 18:49:40 +02:00
using System.Linq ;
2013-04-07 22:55:05 +02:00
using System.Threading ;
using System.Threading.Tasks ;
2015-10-04 06:23:11 +02:00
using CommonIO ;
2016-06-20 08:19:28 +02:00
using MediaBrowser.Model.Configuration ;
using MediaBrowser.Common.Configuration ;
2016-06-23 19:04:18 +02:00
using MediaBrowser.Common.Extensions ;
2016-07-03 04:47:39 +02:00
using MediaBrowser.Common.Net ;
2013-04-07 22:55:05 +02:00
2014-03-27 20:30:21 +01:00
namespace MediaBrowser.MediaEncoding.Encoder
2013-04-07 22:55:05 +02:00
{
/// <summary>
/// Class MediaEncoder
/// </summary>
public class MediaEncoder : IMediaEncoder , IDisposable
{
/// <summary>
/// The _logger
/// </summary>
private readonly ILogger _logger ;
/// <summary>
/// Gets the json serializer.
/// </summary>
/// <value>The json serializer.</value>
private readonly IJsonSerializer _jsonSerializer ;
2015-02-01 20:01:21 +01:00
/// <summary>
/// The _thumbnail resource pool
/// </summary>
private readonly SemaphoreSlim _thumbnailResourcePool = new SemaphoreSlim ( 1 , 1 ) ;
2013-04-07 22:55:05 +02:00
/// <summary>
/// The video image resource pool
/// </summary>
2013-04-15 17:10:12 +02:00
private readonly SemaphoreSlim _videoImageResourcePool = new SemaphoreSlim ( 1 , 1 ) ;
2013-04-07 22:55:05 +02:00
/// <summary>
/// The audio image resource pool
/// </summary>
2013-11-17 16:27:48 +01:00
private readonly SemaphoreSlim _audioImageResourcePool = new SemaphoreSlim ( 2 , 2 ) ;
2013-04-07 22:55:05 +02:00
/// <summary>
/// The FF probe resource pool
/// </summary>
2013-11-17 16:27:48 +01:00
private readonly SemaphoreSlim _ffProbeResourcePool = new SemaphoreSlim ( 2 , 2 ) ;
2014-03-27 20:30:21 +01:00
2013-09-23 17:37:50 +02:00
public string FFMpegPath { get ; private set ; }
2013-04-07 22:55:05 +02:00
2013-09-23 17:37:50 +02:00
public string FFProbePath { get ; private set ; }
2015-01-02 06:36:27 +01:00
protected readonly IServerConfigurationManager ConfigurationManager ;
protected readonly IFileSystem FileSystem ;
protected readonly ILiveTvManager LiveTvManager ;
protected readonly IIsoManager IsoManager ;
protected readonly ILibraryManager LibraryManager ;
protected readonly IChannelManager ChannelManager ;
protected readonly ISessionManager SessionManager ;
2015-01-02 07:12:58 +01:00
protected readonly Func < ISubtitleEncoder > SubtitleEncoder ;
2015-03-08 05:44:31 +01:00
protected readonly Func < IMediaSourceManager > MediaSourceManager ;
2016-07-03 04:47:39 +02:00
private readonly IHttpClient _httpClient ;
private readonly IZipClient _zipClient ;
2015-01-02 07:12:58 +01:00
2015-04-11 19:59:55 +02:00
private readonly List < ProcessWrapper > _runningProcesses = new List < ProcessWrapper > ( ) ;
2016-06-20 08:19:28 +02:00
private readonly bool _hasExternalEncoder ;
2015-04-10 16:01:16 +02:00
2016-07-03 04:47:39 +02:00
public MediaEncoder ( ILogger logger , IJsonSerializer jsonSerializer , string ffMpegPath , string ffProbePath , bool hasExternalEncoder , IServerConfigurationManager configurationManager , IFileSystem fileSystem , ILiveTvManager liveTvManager , IIsoManager isoManager , ILibraryManager libraryManager , IChannelManager channelManager , ISessionManager sessionManager , Func < ISubtitleEncoder > subtitleEncoder , Func < IMediaSourceManager > mediaSourceManager , IHttpClient httpClient , IZipClient zipClient )
2013-04-07 22:55:05 +02:00
{
_logger = logger ;
_jsonSerializer = jsonSerializer ;
2015-01-02 06:36:27 +01:00
ConfigurationManager = configurationManager ;
FileSystem = fileSystem ;
LiveTvManager = liveTvManager ;
IsoManager = isoManager ;
LibraryManager = libraryManager ;
ChannelManager = channelManager ;
SessionManager = sessionManager ;
2015-01-02 07:12:58 +01:00
SubtitleEncoder = subtitleEncoder ;
2015-03-08 05:44:31 +01:00
MediaSourceManager = mediaSourceManager ;
2016-07-03 04:47:39 +02:00
_httpClient = httpClient ;
_zipClient = zipClient ;
2013-09-23 17:37:50 +02:00
FFProbePath = ffProbePath ;
FFMpegPath = ffMpegPath ;
2016-06-20 08:19:28 +02:00
2016-06-20 08:45:35 +02:00
_hasExternalEncoder = hasExternalEncoder ;
2016-06-20 08:19:28 +02:00
}
2016-06-29 07:49:31 +02:00
public string EncoderLocationType
{
get
{
if ( _hasExternalEncoder )
{
return "External" ;
}
if ( string . IsNullOrWhiteSpace ( FFMpegPath ) )
{
return null ;
}
if ( IsSystemInstalledPath ( FFMpegPath ) )
{
return "System" ;
}
return "Custom" ;
}
}
private bool IsSystemInstalledPath ( string path )
{
if ( path . IndexOf ( "/" , StringComparison . Ordinal ) = = - 1 & & path . IndexOf ( "\\" , StringComparison . Ordinal ) = = - 1 )
{
return true ;
}
return false ;
}
2016-06-30 06:23:52 +02:00
public async Task Init ( )
{
InitPaths ( ) ;
if ( ! string . IsNullOrWhiteSpace ( FFMpegPath ) )
{
var result = new EncoderValidator ( _logger ) . Validate ( FFMpegPath ) ;
SetAvailableDecoders ( result . Item1 ) ;
SetAvailableEncoders ( result . Item2 ) ;
2016-07-03 04:47:39 +02:00
if ( Environment . OSVersion . Platform = = PlatformID . Win32NT )
{
var directory = Path . GetDirectoryName ( FFMpegPath ) ;
2016-07-08 06:00:37 +02:00
if ( ! string . IsNullOrWhiteSpace ( directory ) & & FileSystem . ContainsSubPath ( ConfigurationManager . ApplicationPaths . ProgramDataPath , directory ) )
2016-07-03 04:47:39 +02:00
{
await new FontConfigLoader ( _httpClient , ConfigurationManager . ApplicationPaths , _logger , _zipClient ,
FileSystem ) . DownloadFonts ( directory ) . ConfigureAwait ( false ) ;
}
}
2016-06-30 06:23:52 +02:00
}
}
private void InitPaths ( )
2016-06-20 08:19:28 +02:00
{
ConfigureEncoderPaths ( ) ;
2016-06-20 08:45:35 +02:00
if ( _hasExternalEncoder )
{
LogPaths ( ) ;
return ;
}
// If the path was passed in, save it into config now.
var encodingOptions = GetEncodingOptions ( ) ;
var appPath = encodingOptions . EncoderAppPath ;
2016-06-29 04:45:37 +02:00
var valueToSave = FFMpegPath ;
2016-06-29 07:49:31 +02:00
if ( ! string . IsNullOrWhiteSpace ( valueToSave ) )
2016-06-29 04:45:37 +02:00
{
2016-06-29 07:49:31 +02:00
// if using system variable, don't save this.
if ( IsSystemInstalledPath ( valueToSave ) )
{
valueToSave = null ;
}
2016-06-29 04:45:37 +02:00
}
if ( ! string . Equals ( valueToSave , appPath , StringComparison . Ordinal ) )
2016-06-20 08:45:35 +02:00
{
2016-06-29 04:45:37 +02:00
encodingOptions . EncoderAppPath = valueToSave ;
2016-06-20 08:45:35 +02:00
ConfigurationManager . SaveConfiguration ( "encoding" , encodingOptions ) ;
}
2016-06-20 08:19:28 +02:00
}
2016-06-29 07:49:31 +02:00
public async Task UpdateEncoderPath ( string path , string pathType )
2016-06-23 19:04:18 +02:00
{
2016-06-29 07:49:31 +02:00
if ( _hasExternalEncoder )
{
return ;
}
Tuple < string , string > newPaths ;
if ( string . Equals ( pathType , "system" , StringComparison . OrdinalIgnoreCase ) )
2016-06-23 19:04:18 +02:00
{
2016-06-29 07:49:31 +02:00
path = "ffmpeg" ;
newPaths = TestForInstalledVersions ( ) ;
2016-06-23 19:04:18 +02:00
}
2016-06-29 07:49:31 +02:00
else if ( string . Equals ( pathType , "custom" , StringComparison . OrdinalIgnoreCase ) )
{
if ( string . IsNullOrWhiteSpace ( path ) )
{
throw new ArgumentNullException ( "path" ) ;
}
2016-06-23 19:04:18 +02:00
2016-06-29 07:49:31 +02:00
if ( ! File . Exists ( path ) & & ! Directory . Exists ( path ) )
{
throw new ResourceNotFoundException ( ) ;
}
newPaths = GetEncoderPaths ( path ) ;
}
else
2016-06-23 19:04:18 +02:00
{
2016-06-29 07:49:31 +02:00
throw new ArgumentException ( "Unexpected pathType value" ) ;
2016-06-23 19:04:18 +02:00
}
if ( string . IsNullOrWhiteSpace ( newPaths . Item1 ) )
{
throw new ResourceNotFoundException ( "ffmpeg not found" ) ;
}
if ( string . IsNullOrWhiteSpace ( newPaths . Item2 ) )
{
throw new ResourceNotFoundException ( "ffprobe not found" ) ;
}
var config = GetEncodingOptions ( ) ;
config . EncoderAppPath = path ;
ConfigurationManager . SaveConfiguration ( "encoding" , config ) ;
Init ( ) ;
}
2016-06-20 08:19:28 +02:00
private void ConfigureEncoderPaths ( )
{
if ( _hasExternalEncoder )
{
return ;
}
var appPath = GetEncodingOptions ( ) . EncoderAppPath ;
2016-06-20 08:47:12 +02:00
if ( string . IsNullOrWhiteSpace ( appPath ) )
{
appPath = Path . Combine ( ConfigurationManager . ApplicationPaths . ProgramDataPath , "ffmpeg" ) ;
}
2016-06-29 04:45:37 +02:00
2016-06-23 19:04:18 +02:00
var newPaths = GetEncoderPaths ( appPath ) ;
2016-06-29 04:45:37 +02:00
if ( string . IsNullOrWhiteSpace ( newPaths . Item1 ) | | string . IsNullOrWhiteSpace ( newPaths . Item2 ) )
{
newPaths = TestForInstalledVersions ( ) ;
}
2016-06-23 19:04:18 +02:00
if ( ! string . IsNullOrWhiteSpace ( newPaths . Item1 ) & & ! string . IsNullOrWhiteSpace ( newPaths . Item2 ) )
{
FFMpegPath = newPaths . Item1 ;
FFProbePath = newPaths . Item2 ;
}
LogPaths ( ) ;
}
private Tuple < string , string > GetEncoderPaths ( string configuredPath )
{
var appPath = configuredPath ;
2016-06-20 08:47:12 +02:00
2016-06-20 08:45:35 +02:00
if ( ! string . IsNullOrWhiteSpace ( appPath ) )
2016-06-20 08:19:28 +02:00
{
2016-06-20 08:45:35 +02:00
if ( Directory . Exists ( appPath ) )
{
2016-06-23 19:04:18 +02:00
return GetPathsFromDirectory ( appPath ) ;
2016-06-20 08:45:35 +02:00
}
2016-06-20 08:19:28 +02:00
2016-06-23 19:04:18 +02:00
if ( File . Exists ( appPath ) )
2016-06-20 08:45:35 +02:00
{
2016-06-23 19:04:18 +02:00
return new Tuple < string , string > ( appPath , GetProbePathFromEncoderPath ( appPath ) ) ;
2016-06-20 08:45:35 +02:00
}
2016-06-20 08:19:28 +02:00
}
2016-06-23 19:04:18 +02:00
return new Tuple < string , string > ( null , null ) ;
2016-06-20 08:19:28 +02:00
}
2016-06-29 04:45:37 +02:00
private Tuple < string , string > TestForInstalledVersions ( )
{
string encoderPath = null ;
string probePath = null ;
if ( TestSystemInstalled ( "ffmpeg" ) )
{
encoderPath = "ffmpeg" ;
}
if ( TestSystemInstalled ( "ffprobe" ) )
{
probePath = "ffprobe" ;
}
return new Tuple < string , string > ( encoderPath , probePath ) ;
}
private bool TestSystemInstalled ( string app )
{
try
{
var startInfo = new ProcessStartInfo
{
FileName = app ,
Arguments = "-v" ,
UseShellExecute = false ,
CreateNoWindow = true ,
WindowStyle = ProcessWindowStyle . Hidden ,
ErrorDialog = false
} ;
using ( var process = Process . Start ( startInfo ) )
{
process . WaitForExit ( ) ;
}
_logger . Debug ( "System app installed: " + app ) ;
return true ;
}
catch
{
_logger . Debug ( "System app not installed: " + app ) ;
return false ;
}
}
2016-06-29 07:49:31 +02:00
private Tuple < string , string > GetPathsFromDirectory ( string path )
2016-06-20 08:19:28 +02:00
{
// Since we can't predict the file extension, first try directly within the folder
// If that doesn't pan out, then do a recursive search
var files = Directory . GetFiles ( path ) ;
2016-06-23 19:04:18 +02:00
var ffmpegPath = files . FirstOrDefault ( i = > string . Equals ( Path . GetFileNameWithoutExtension ( i ) , "ffmpeg" , StringComparison . OrdinalIgnoreCase ) ) ;
var ffprobePath = files . FirstOrDefault ( i = > string . Equals ( Path . GetFileNameWithoutExtension ( i ) , "ffprobe" , StringComparison . OrdinalIgnoreCase ) ) ;
2016-06-20 08:19:28 +02:00
2016-06-23 19:04:18 +02:00
if ( string . IsNullOrWhiteSpace ( ffmpegPath ) | | ! File . Exists ( ffmpegPath ) )
2016-06-20 08:19:28 +02:00
{
files = Directory . GetFiles ( path , "*" , SearchOption . AllDirectories ) ;
2016-06-23 19:04:18 +02:00
ffmpegPath = files . FirstOrDefault ( i = > string . Equals ( Path . GetFileNameWithoutExtension ( i ) , "ffmpeg" , StringComparison . OrdinalIgnoreCase ) ) ;
2016-06-30 05:11:25 +02:00
if ( ! string . IsNullOrWhiteSpace ( ffmpegPath ) )
{
ffprobePath = GetProbePathFromEncoderPath ( ffmpegPath ) ;
}
2016-06-20 08:19:28 +02:00
}
2016-06-23 19:04:18 +02:00
return new Tuple < string , string > ( ffmpegPath , ffprobePath ) ;
2016-06-20 08:19:28 +02:00
}
2016-06-23 19:04:18 +02:00
private string GetProbePathFromEncoderPath ( string appPath )
2016-06-20 08:19:28 +02:00
{
2016-06-23 19:04:18 +02:00
return Directory . GetFiles ( Path . GetDirectoryName ( appPath ) )
2016-06-20 08:19:28 +02:00
. FirstOrDefault ( i = > string . Equals ( Path . GetFileNameWithoutExtension ( i ) , "ffprobe" , StringComparison . OrdinalIgnoreCase ) ) ;
}
private void LogPaths ( )
{
_logger . Info ( "FFMpeg: {0}" , FFMpegPath ? ? "not found" ) ;
_logger . Info ( "FFProbe: {0}" , FFProbePath ? ? "not found" ) ;
}
private EncodingOptions GetEncodingOptions ( )
{
return ConfigurationManager . GetConfiguration < EncodingOptions > ( "encoding" ) ;
2013-04-07 22:55:05 +02:00
}
2016-04-30 21:16:43 +02:00
private List < string > _encoders = new List < string > ( ) ;
2015-09-20 19:56:26 +02:00
public void SetAvailableEncoders ( List < string > list )
{
2016-04-30 21:16:43 +02:00
_encoders = list . ToList ( ) ;
//_logger.Info("Supported encoders: {0}", string.Join(",", list.ToArray()));
2015-09-20 19:56:26 +02:00
}
private List < string > _decoders = new List < string > ( ) ;
public void SetAvailableDecoders ( List < string > list )
{
_decoders = list . ToList ( ) ;
2016-04-30 21:16:43 +02:00
//_logger.Info("Supported decoders: {0}", string.Join(",", list.ToArray()));
}
2016-08-05 07:12:25 +02:00
public bool SupportsEncoder ( string encoder )
2016-04-30 21:16:43 +02:00
{
2016-08-05 07:12:25 +02:00
return _encoders . Contains ( encoder , StringComparer . OrdinalIgnoreCase ) ;
2015-09-20 19:56:26 +02:00
}
public bool SupportsDecoder ( string decoder )
{
return _decoders . Contains ( decoder , StringComparer . OrdinalIgnoreCase ) ;
}
2016-04-30 21:16:43 +02:00
public bool CanEncodeToAudioCodec ( string codec )
{
if ( string . Equals ( codec , "opus" , StringComparison . OrdinalIgnoreCase ) )
{
codec = "libopus" ;
}
else if ( string . Equals ( codec , "mp3" , StringComparison . OrdinalIgnoreCase ) )
{
codec = "libmp3lame" ;
}
return SupportsEncoder ( codec ) ;
}
2013-04-07 22:55:05 +02:00
/// <summary>
/// Gets the encoder path.
/// </summary>
/// <value>The encoder path.</value>
public string EncoderPath
{
get { return FFMpegPath ; }
}
/// <summary>
/// Gets the media info.
/// </summary>
2015-04-05 17:01:57 +02:00
/// <param name="request">The request.</param>
2013-04-07 22:55:05 +02:00
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task.</returns>
2016-02-18 03:55:15 +01:00
public Task < MediaInfo > GetMediaInfo ( MediaInfoRequest request , CancellationToken cancellationToken )
2013-04-07 22:55:05 +02:00
{
2015-04-05 17:01:57 +02:00
var extractChapters = request . MediaType = = DlnaProfileType . Video & & request . ExtractChapters ;
2015-09-24 19:50:49 +02:00
var inputFiles = MediaEncoderHelpers . GetInputArgument ( FileSystem , request . InputPath , request . Protocol , request . MountedIso , request . PlayableStreamFileNames ) ;
2015-04-05 17:01:57 +02:00
2015-12-19 18:48:42 +01:00
return GetMediaInfoInternal ( GetInputArgument ( inputFiles , request . Protocol ) , request . InputPath , request . Protocol , extractChapters ,
2015-04-25 05:30:44 +02:00
GetProbeSizeArgument ( inputFiles , request . Protocol ) , request . MediaType = = DlnaProfileType . Audio , request . VideoType , cancellationToken ) ;
2013-04-07 22:55:05 +02:00
}
/// <summary>
/// Gets the input argument.
/// </summary>
/// <param name="inputFiles">The input files.</param>
2014-06-17 03:56:23 +02:00
/// <param name="protocol">The protocol.</param>
2013-04-07 22:55:05 +02:00
/// <returns>System.String.</returns>
/// <exception cref="System.ArgumentException">Unrecognized InputType</exception>
2014-06-17 03:56:23 +02:00
public string GetInputArgument ( string [ ] inputFiles , MediaProtocol protocol )
2013-04-07 22:55:05 +02:00
{
2014-06-17 03:56:23 +02:00
return EncodingUtils . GetInputArgument ( inputFiles . ToList ( ) , protocol ) ;
2013-05-01 22:07:20 +02:00
}
2013-04-07 22:55:05 +02:00
/// <summary>
/// Gets the probe size argument.
/// </summary>
2014-06-17 03:56:23 +02:00
/// <param name="inputFiles">The input files.</param>
/// <param name="protocol">The protocol.</param>
2013-04-07 22:55:05 +02:00
/// <returns>System.String.</returns>
2014-06-17 03:56:23 +02:00
public string GetProbeSizeArgument ( string [ ] inputFiles , MediaProtocol protocol )
2013-04-07 22:55:05 +02:00
{
2014-06-20 06:50:30 +02:00
return EncodingUtils . GetProbeSizeArgument ( inputFiles . Length > 1 ) ;
2013-04-07 22:55:05 +02:00
}
/// <summary>
/// Gets the media info internal.
/// </summary>
/// <param name="inputPath">The input path.</param>
2015-04-04 21:35:29 +02:00
/// <param name="primaryPath">The primary path.</param>
/// <param name="protocol">The protocol.</param>
2013-04-07 22:55:05 +02:00
/// <param name="extractChapters">if set to <c>true</c> [extract chapters].</param>
/// <param name="probeSizeArgument">The probe size argument.</param>
2015-04-04 21:35:29 +02:00
/// <param name="isAudio">if set to <c>true</c> [is audio].</param>
2015-04-25 05:30:44 +02:00
/// <param name="videoType">Type of the video.</param>
2013-04-07 22:55:05 +02:00
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task{MediaInfoResult}.</returns>
2015-12-19 18:48:42 +01:00
/// <exception cref="System.ApplicationException">ffprobe failed - streams and format are both null.</exception>
2016-02-18 03:55:15 +01:00
private async Task < MediaInfo > GetMediaInfoInternal ( string inputPath ,
2015-04-10 21:08:09 +02:00
string primaryPath ,
MediaProtocol protocol ,
bool extractChapters ,
2014-03-27 20:30:21 +01:00
string probeSizeArgument ,
2015-04-04 21:35:29 +02:00
bool isAudio ,
2015-04-25 05:30:44 +02:00
VideoType videoType ,
2014-03-27 20:30:21 +01:00
CancellationToken cancellationToken )
2013-04-07 22:55:05 +02:00
{
2014-03-26 22:05:31 +01:00
var args = extractChapters
? "{0} -i {1} -threads 0 -v info -print_format json -show_streams -show_chapters -show_format"
: "{0} -i {1} -threads 0 -v info -print_format json -show_streams -show_format" ;
2013-04-07 22:55:05 +02:00
var process = new Process
2014-01-17 17:36:01 +01:00
{
StartInfo = new ProcessStartInfo
2013-04-07 22:55:05 +02:00
{
2014-01-17 17:36:01 +01:00
CreateNoWindow = true ,
UseShellExecute = false ,
// Must consume both or ffmpeg may hang due to deadlocks. See comments below.
2016-07-02 06:25:34 +02:00
RedirectStandardOutput = true ,
//RedirectStandardError = true,
2016-08-03 06:33:34 +02:00
RedirectStandardInput = false ,
2014-01-17 17:36:01 +01:00
FileName = FFProbePath ,
2014-03-26 22:05:31 +01:00
Arguments = string . Format ( args ,
2014-06-29 19:35:05 +02:00
probeSizeArgument , inputPath ) . Trim ( ) ,
2014-01-17 17:36:01 +01:00
WindowStyle = ProcessWindowStyle . Hidden ,
ErrorDialog = false
} ,
EnableRaisingEvents = true
} ;
2013-04-07 22:55:05 +02:00
_logger . Debug ( "{0} {1}" , process . StartInfo . FileName , process . StartInfo . Arguments ) ;
2016-08-03 06:33:34 +02:00
using ( var processWrapper = new ProcessWrapper ( process , this , _logger , false ) )
2013-04-15 17:10:12 +02:00
{
2015-10-16 06:46:41 +02:00
await _ffProbeResourcePool . WaitAsync ( cancellationToken ) . ConfigureAwait ( false ) ;
2015-05-06 14:56:26 +02:00
try
{
StartProcess ( processWrapper ) ;
}
catch ( Exception ex )
{
_ffProbeResourcePool . Release ( ) ;
2013-04-15 17:10:12 +02:00
2015-05-06 14:56:26 +02:00
_logger . ErrorException ( "Error starting ffprobe" , ex ) ;
2013-04-07 22:55:05 +02:00
2015-05-06 14:56:26 +02:00
throw ;
}
2013-04-24 02:43:27 +02:00
2015-05-06 14:56:26 +02:00
try
{
2016-07-02 04:16:05 +02:00
//process.BeginErrorReadLine();
2013-04-07 22:55:05 +02:00
2015-05-06 14:56:26 +02:00
var result = _jsonSerializer . DeserializeFromStream < InternalMediaInfoResult > ( process . StandardOutput . BaseStream ) ;
2015-04-10 21:08:09 +02:00
2015-09-30 07:24:23 +02:00
if ( result . streams = = null & & result . format = = null )
2015-04-10 21:08:09 +02:00
{
2015-09-30 07:24:23 +02:00
throw new ApplicationException ( "ffprobe failed - streams and format are both null." ) ;
}
if ( result . streams ! = null )
{
// Normalize aspect ratio if invalid
foreach ( var stream in result . streams )
2015-04-10 21:08:09 +02:00
{
2015-09-30 07:24:23 +02:00
if ( string . Equals ( stream . display_aspect_ratio , "0:1" , StringComparison . OrdinalIgnoreCase ) )
2015-04-10 21:08:09 +02:00
{
2015-09-30 07:24:23 +02:00
stream . display_aspect_ratio = string . Empty ;
}
if ( string . Equals ( stream . sample_aspect_ratio , "0:1" , StringComparison . OrdinalIgnoreCase ) )
{
stream . sample_aspect_ratio = string . Empty ;
2015-04-10 21:08:09 +02:00
}
}
2015-09-30 07:24:23 +02:00
}
2015-04-10 21:08:09 +02:00
2015-09-30 07:24:23 +02:00
var mediaInfo = new ProbeResultNormalizer ( _logger , FileSystem ) . GetMediaInfo ( result , videoType , isAudio , primaryPath , protocol ) ;
2015-04-10 21:08:09 +02:00
2015-12-19 19:29:53 +01:00
var videoStream = mediaInfo . MediaStreams . FirstOrDefault ( i = > i . Type = = MediaStreamType . Video ) ;
2015-12-19 18:45:50 +01:00
2015-12-19 19:29:53 +01:00
if ( videoStream ! = null )
{
var isInterlaced = await DetectInterlaced ( mediaInfo , videoStream , inputPath , probeSizeArgument ) . ConfigureAwait ( false ) ;
2015-12-19 18:45:50 +01:00
2015-12-19 19:29:53 +01:00
if ( isInterlaced )
{
videoStream . IsInterlaced = true ;
}
}
2015-12-19 18:45:50 +01:00
2015-09-30 07:24:23 +02:00
return mediaInfo ;
2015-04-10 21:08:09 +02:00
}
2015-05-06 14:56:26 +02:00
catch
{
StopProcess ( processWrapper , 100 , true ) ;
2013-04-07 22:55:05 +02:00
2015-05-06 14:56:26 +02:00
throw ;
}
finally
{
_ffProbeResourcePool . Release ( ) ;
}
2013-04-07 22:55:05 +02:00
}
2015-12-19 18:45:50 +01:00
}
private async Task < bool > DetectInterlaced ( MediaSourceInfo video , MediaStream videoStream , string inputPath , string probeSizeArgument )
{
if ( video . Protocol ! = MediaProtocol . File )
{
return false ;
}
2016-02-01 18:02:58 +01:00
var formats = ( video . Container ? ? string . Empty ) . Split ( ',' ) . ToList ( ) ;
2016-03-18 18:28:45 +01:00
var enableInterlacedDection = formats . Contains ( "vob" , StringComparer . OrdinalIgnoreCase ) | |
formats . Contains ( "m2ts" , StringComparer . OrdinalIgnoreCase ) | |
formats . Contains ( "ts" , StringComparer . OrdinalIgnoreCase ) | |
formats . Contains ( "mpegts" , StringComparer . OrdinalIgnoreCase ) | |
2016-02-01 18:02:58 +01:00
formats . Contains ( "wtv" , StringComparer . OrdinalIgnoreCase ) ;
2016-04-30 21:16:43 +02:00
2016-02-01 18:02:58 +01:00
// If it's mpeg based, assume true
if ( ( videoStream . Codec ? ? string . Empty ) . IndexOf ( "mpeg" , StringComparison . OrdinalIgnoreCase ) ! = - 1 )
2015-12-19 18:45:50 +01:00
{
2016-02-01 18:02:58 +01:00
if ( enableInterlacedDection )
{
return true ;
}
}
else
{
// If the video codec is not some form of mpeg, then take a shortcut and limit this to containers that are likely to have interlaced content
if ( ! enableInterlacedDection )
2015-12-19 19:29:53 +01:00
{
return false ;
}
2015-12-19 18:45:50 +01:00
}
2016-01-13 21:59:17 +01:00
var args = "{0} -i {1} -map 0:v:{2} -an -filter:v idet -frames:v 500 -an -f null /dev/null" ;
2015-12-19 18:45:50 +01:00
var process = new Process
{
StartInfo = new ProcessStartInfo
{
CreateNoWindow = true ,
UseShellExecute = false ,
// Must consume both or ffmpeg may hang due to deadlocks. See comments below.
2016-07-02 23:45:20 +02:00
//RedirectStandardOutput = true,
RedirectStandardError = true ,
2016-08-03 06:33:34 +02:00
RedirectStandardInput = false ,
2015-12-19 18:45:50 +01:00
FileName = FFMpegPath ,
Arguments = string . Format ( args , probeSizeArgument , inputPath , videoStream . Index . ToString ( CultureInfo . InvariantCulture ) ) . Trim ( ) ,
WindowStyle = ProcessWindowStyle . Hidden ,
ErrorDialog = false
} ,
EnableRaisingEvents = true
} ;
2015-12-19 18:50:44 +01:00
_logger . Debug ( "{0} {1}" , process . StartInfo . FileName , process . StartInfo . Arguments ) ;
2015-12-19 18:45:50 +01:00
var idetFoundInterlaced = false ;
2016-08-03 06:33:34 +02:00
using ( var processWrapper = new ProcessWrapper ( process , this , _logger , false ) )
2015-12-19 18:45:50 +01:00
{
try
{
StartProcess ( processWrapper ) ;
}
catch ( Exception ex )
{
_logger . ErrorException ( "Error starting ffprobe" , ex ) ;
throw ;
}
try
{
2016-07-02 04:16:05 +02:00
//process.BeginOutputReadLine();
2015-12-19 18:45:50 +01:00
using ( var reader = new StreamReader ( process . StandardError . BaseStream ) )
{
while ( ! reader . EndOfStream )
{
var line = await reader . ReadLineAsync ( ) . ConfigureAwait ( false ) ;
if ( line . StartsWith ( "[Parsed_idet" , StringComparison . OrdinalIgnoreCase ) )
{
var idetResult = AnalyzeIdetResult ( line ) ;
if ( idetResult . HasValue )
{
if ( ! idetResult . Value )
{
return false ;
}
idetFoundInterlaced = true ;
}
}
}
}
}
catch
{
StopProcess ( processWrapper , 100 , true ) ;
throw ;
}
}
return idetFoundInterlaced ;
2015-04-10 21:08:09 +02:00
}
2013-04-07 22:55:05 +02:00
2015-12-19 18:45:50 +01:00
private bool? AnalyzeIdetResult ( string line )
{
// As you can see, the filter only guessed one frame as progressive.
// Results like this are pretty typical. So if less than 30% of the detections are in the "Undetermined" category, then I only consider the video to be interlaced if at least 65% of the identified frames are in either the TFF or BFF category.
// In this case (310 + 311)/(622) = 99.8% which is well over the 65% metric. I may refine that number with more testing but I honestly do not believe I will need to.
// http://awel.domblogger.net/videoTranscode/interlace.html
var index = line . IndexOf ( "detection:" , StringComparison . OrdinalIgnoreCase ) ;
if ( index = = - 1 )
{
return null ;
}
line = line . Substring ( index ) . Trim ( ) ;
var parts = line . Split ( ' ' ) . Where ( i = > ! string . IsNullOrWhiteSpace ( i ) ) . Select ( i = > i . Trim ( ) ) . ToList ( ) ;
if ( parts . Count < 2 )
{
return null ;
}
double tff = 0 ;
double bff = 0 ;
double progressive = 0 ;
double undetermined = 0 ;
double total = 0 ;
for ( var i = 0 ; i < parts . Count - 1 ; i + + )
{
var part = parts [ i ] ;
if ( string . Equals ( part , "tff:" , StringComparison . OrdinalIgnoreCase ) )
{
tff = GetNextPart ( parts , i ) ;
total + = tff ;
}
else if ( string . Equals ( part , "bff:" , StringComparison . OrdinalIgnoreCase ) )
{
bff = GetNextPart ( parts , i ) ;
total + = tff ;
}
else if ( string . Equals ( part , "progressive:" , StringComparison . OrdinalIgnoreCase ) )
{
progressive = GetNextPart ( parts , i ) ;
total + = progressive ;
}
else if ( string . Equals ( part , "undetermined:" , StringComparison . OrdinalIgnoreCase ) )
{
undetermined = GetNextPart ( parts , i ) ;
total + = undetermined ;
}
}
if ( total = = 0 )
{
return null ;
}
if ( ( undetermined / total ) > = . 3 )
{
return false ;
}
2016-01-13 21:59:17 +01:00
if ( ( ( tff + bff ) / total ) > = . 4 )
2015-12-19 18:45:50 +01:00
{
return true ;
}
return false ;
}
private int GetNextPart ( List < string > parts , int index )
{
var next = parts [ index + 1 ] ;
int value ;
if ( int . TryParse ( next , NumberStyles . Any , CultureInfo . InvariantCulture , out value ) )
{
return value ;
}
return 0 ;
}
2013-04-24 02:43:27 +02:00
/// <summary>
/// The us culture
/// </summary>
2013-04-10 04:28:24 +02:00
protected readonly CultureInfo UsCulture = new CultureInfo ( "en-US" ) ;
2013-04-24 02:43:27 +02:00
2016-07-01 04:35:18 +02:00
public Task < string > ExtractAudioImage ( string path , int? imageStreamIndex , CancellationToken cancellationToken )
2014-03-27 20:30:21 +01:00
{
2016-01-11 17:52:22 +01:00
return ExtractImage ( new [ ] { path } , imageStreamIndex , MediaProtocol . File , true , null , null , cancellationToken ) ;
2014-03-27 20:30:21 +01:00
}
2016-07-01 04:35:18 +02:00
public Task < string > ExtractVideoImage ( string [ ] inputFiles , MediaProtocol protocol , Video3DFormat ? threedFormat , TimeSpan ? offset , CancellationToken cancellationToken )
2014-03-27 20:30:21 +01:00
{
2016-01-11 17:52:22 +01:00
return ExtractImage ( inputFiles , null , protocol , false , threedFormat , offset , cancellationToken ) ;
2014-03-27 20:30:21 +01:00
}
2016-07-01 04:35:18 +02:00
public Task < string > ExtractVideoImage ( string [ ] inputFiles , MediaProtocol protocol , int? imageStreamIndex , CancellationToken cancellationToken )
2016-04-13 22:49:16 +02:00
{
return ExtractImage ( inputFiles , imageStreamIndex , protocol , false , null , null , cancellationToken ) ;
}
2016-07-01 04:35:18 +02:00
private async Task < string > ExtractImage ( string [ ] inputFiles , int? imageStreamIndex , MediaProtocol protocol , bool isAudio ,
2014-02-04 21:19:29 +01:00
Video3DFormat ? threedFormat , TimeSpan ? offset , CancellationToken cancellationToken )
{
var resourcePool = isAudio ? _audioImageResourcePool : _videoImageResourcePool ;
2014-06-17 03:56:23 +02:00
var inputArgument = GetInputArgument ( inputFiles , protocol ) ;
2014-02-04 21:19:29 +01:00
2016-01-13 21:59:17 +01:00
if ( isAudio )
{
if ( imageStreamIndex . HasValue & & imageStreamIndex . Value > 0 )
{
// It seems for audio files we need to subtract 1 (for the audio stream??)
imageStreamIndex = imageStreamIndex . Value - 1 ;
}
}
else
2014-02-04 21:19:29 +01:00
{
try
{
2016-01-11 17:52:22 +01:00
return await ExtractImageInternal ( inputArgument , imageStreamIndex , protocol , threedFormat , offset , true , resourcePool , cancellationToken ) . ConfigureAwait ( false ) ;
2014-02-04 21:19:29 +01:00
}
2015-04-11 19:59:55 +02:00
catch ( ArgumentException )
{
throw ;
}
2014-02-04 21:19:29 +01:00
catch
{
_logger . Error ( "I-frame image extraction failed, will attempt standard way. Input: {0}" , inputArgument ) ;
}
}
2016-01-11 17:52:22 +01:00
return await ExtractImageInternal ( inputArgument , imageStreamIndex , protocol , threedFormat , offset , false , resourcePool , cancellationToken ) . ConfigureAwait ( false ) ;
2014-02-04 21:19:29 +01:00
}
2016-07-01 04:35:18 +02:00
private async Task < string > ExtractImageInternal ( string inputPath , int? imageStreamIndex , MediaProtocol protocol , Video3DFormat ? threedFormat , TimeSpan ? offset , bool useIFrame , SemaphoreSlim resourcePool , CancellationToken cancellationToken )
2014-02-04 21:19:29 +01:00
{
if ( string . IsNullOrEmpty ( inputPath ) )
{
throw new ArgumentNullException ( "inputPath" ) ;
}
2016-07-01 04:35:18 +02:00
var tempExtractPath = Path . Combine ( ConfigurationManager . ApplicationPaths . TempDirectory , Guid . NewGuid ( ) + ".jpg" ) ;
Directory . CreateDirectory ( Path . GetDirectoryName ( tempExtractPath ) ) ;
2014-02-04 21:19:29 +01:00
// apply some filters to thumbnail extracted below (below) crop any black lines that we made and get the correct ar then scale to width 600.
// This filter chain may have adverse effects on recorded tv thumbnails if ar changes during presentation ex. commercials @ diff ar
2014-03-25 05:57:01 +01:00
var vf = "scale=600:trunc(600/dar/2)*2" ;
2014-02-04 21:19:29 +01:00
if ( threedFormat . HasValue )
{
switch ( threedFormat . Value )
{
case Video3DFormat . HalfSideBySide :
2014-03-25 05:57:01 +01:00
vf = "crop=iw/2:ih:0:0,scale=(iw*2):ih,setdar=dar=a,crop=min(iw\\,ih*dar):min(ih\\,iw/dar):(iw-min(iw\\,iw*sar))/2:(ih - min (ih\\,ih/sar))/2,setsar=sar=1,scale=600:trunc(600/dar/2)*2" ;
2014-02-04 21:19:29 +01:00
// hsbs crop width in half,scale to correct size, set the display aspect,crop out any black bars we may have made the scale width to 600. Work out the correct height based on the display aspect it will maintain the aspect where -1 in this case (3d) may not.
break ;
case Video3DFormat . FullSideBySide :
2014-03-25 05:57:01 +01:00
vf = "crop=iw/2:ih:0:0,setdar=dar=a,crop=min(iw\\,ih*dar):min(ih\\,iw/dar):(iw-min(iw\\,iw*sar))/2:(ih - min (ih\\,ih/sar))/2,setsar=sar=1,scale=600:trunc(600/dar/2)*2" ;
2014-02-04 21:19:29 +01:00
//fsbs crop width in half,set the display aspect,crop out any black bars we may have made the scale width to 600.
break ;
case Video3DFormat . HalfTopAndBottom :
2014-03-25 05:57:01 +01:00
vf = "crop=iw:ih/2:0:0,scale=(iw*2):ih),setdar=dar=a,crop=min(iw\\,ih*dar):min(ih\\,iw/dar):(iw-min(iw\\,iw*sar))/2:(ih - min (ih\\,ih/sar))/2,setsar=sar=1,scale=600:trunc(600/dar/2)*2" ;
2014-02-04 21:19:29 +01:00
//htab crop heigh in half,scale to correct size, set the display aspect,crop out any black bars we may have made the scale width to 600
break ;
case Video3DFormat . FullTopAndBottom :
2014-03-25 05:57:01 +01:00
vf = "crop=iw:ih/2:0:0,setdar=dar=a,crop=min(iw\\,ih*dar):min(ih\\,iw/dar):(iw-min(iw\\,iw*sar))/2:(ih - min (ih\\,ih/sar))/2,setsar=sar=1,scale=600:trunc(600/dar/2)*2" ;
2014-02-04 21:19:29 +01:00
// ftab crop heigt in half, set the display aspect,crop out any black bars we may have made the scale width to 600
break ;
2016-02-11 20:11:28 +01:00
default :
break ;
2014-02-04 21:19:29 +01:00
}
}
2016-01-13 21:59:17 +01:00
var mapArg = imageStreamIndex . HasValue ? ( " -map 0:v:" + imageStreamIndex . Value . ToString ( CultureInfo . InvariantCulture ) ) : string . Empty ;
2014-02-04 21:19:29 +01:00
// Use ffmpeg to sample 100 (we can drop this if required using thumbnail=50 for 50 frames) frames and pick the best thumbnail. Have a fall back just in case.
2016-08-10 21:15:41 +02:00
var args = useIFrame ? string . Format ( "-i {0}{3} -threads 0 -v quiet -vframes 1 -vf \"{2},thumbnail=30\" -f image2 \"{1}\"" , inputPath , tempExtractPath , vf , mapArg ) :
string . Format ( "-i {0}{3} -threads 0 -v quiet -vframes 1 -vf \"{2}\" -f image2 \"{1}\"" , inputPath , tempExtractPath , vf , mapArg ) ;
2014-02-04 21:19:29 +01:00
2014-06-17 03:56:23 +02:00
var probeSize = GetProbeSizeArgument ( new [ ] { inputPath } , protocol ) ;
2014-02-04 21:19:29 +01:00
if ( ! string . IsNullOrEmpty ( probeSize ) )
{
args = probeSize + " " + args ;
}
if ( offset . HasValue )
{
2014-06-26 19:04:11 +02:00
args = string . Format ( "-ss {0} " , GetTimeParameter ( offset . Value ) ) + args ;
2014-02-04 21:19:29 +01:00
}
var process = new Process
{
StartInfo = new ProcessStartInfo
{
CreateNoWindow = true ,
UseShellExecute = false ,
FileName = FFMpegPath ,
Arguments = args ,
WindowStyle = ProcessWindowStyle . Hidden ,
2016-08-03 06:33:34 +02:00
ErrorDialog = false
2014-02-04 21:19:29 +01:00
}
} ;
2015-01-16 21:54:37 +01:00
_logger . Debug ( "{0} {1}" , process . StartInfo . FileName , process . StartInfo . Arguments ) ;
2015-02-01 21:05:39 +01:00
2016-08-03 06:33:34 +02:00
using ( var processWrapper = new ProcessWrapper ( process , this , _logger , false ) )
2015-05-06 14:56:26 +02:00
{
2015-10-16 06:46:41 +02:00
await resourcePool . WaitAsync ( cancellationToken ) . ConfigureAwait ( false ) ;
2015-05-06 14:56:26 +02:00
bool ranToCompletion ;
2014-02-04 21:19:29 +01:00
2015-05-06 14:56:26 +02:00
try
{
StartProcess ( processWrapper ) ;
2015-04-16 05:23:13 +02:00
2015-05-06 14:56:26 +02:00
ranToCompletion = process . WaitForExit ( 10000 ) ;
2014-02-04 21:19:29 +01:00
2015-05-06 14:56:26 +02:00
if ( ! ranToCompletion )
{
StopProcess ( processWrapper , 1000 , false ) ;
}
}
finally
2015-04-16 05:23:13 +02:00
{
2015-05-06 14:56:26 +02:00
resourcePool . Release ( ) ;
2015-04-16 05:23:13 +02:00
}
2015-05-06 14:56:26 +02:00
var exitCode = ranToCompletion ? processWrapper . ExitCode ? ? 0 : - 1 ;
2016-07-01 04:35:18 +02:00
var file = new FileInfo ( tempExtractPath ) ;
2014-03-27 20:30:21 +01:00
2016-07-01 04:35:18 +02:00
if ( exitCode = = - 1 | | ! file . Exists | | file . Length = = 0 )
2015-05-06 14:56:26 +02:00
{
var msg = string . Format ( "ffmpeg image extraction failed for {0}" , inputPath ) ;
2014-02-04 21:19:29 +01:00
2015-05-06 14:56:26 +02:00
_logger . Error ( msg ) ;
2014-02-04 21:19:29 +01:00
2015-05-06 14:56:26 +02:00
throw new ApplicationException ( msg ) ;
}
2014-02-04 21:19:29 +01:00
2016-07-01 04:35:18 +02:00
return tempExtractPath ;
2014-02-04 21:19:29 +01:00
}
}
2014-06-26 19:04:11 +02:00
public string GetTimeParameter ( long ticks )
{
var time = TimeSpan . FromTicks ( ticks ) ;
return GetTimeParameter ( time ) ;
}
public string GetTimeParameter ( TimeSpan time )
{
return time . ToString ( @"hh\:mm\:ss\.fff" , UsCulture ) ;
}
2014-06-29 19:35:05 +02:00
public async Task ExtractVideoImagesOnInterval ( string [ ] inputFiles ,
MediaProtocol protocol ,
Video3DFormat ? threedFormat ,
TimeSpan interval ,
string targetDirectory ,
string filenamePrefix ,
int? maxWidth ,
CancellationToken cancellationToken )
{
2015-02-01 20:01:21 +01:00
var resourcePool = _thumbnailResourcePool ;
2014-06-29 19:35:05 +02:00
var inputArgument = GetInputArgument ( inputFiles , protocol ) ;
var vf = "fps=fps=1/" + interval . TotalSeconds . ToString ( UsCulture ) ;
if ( maxWidth . HasValue )
{
var maxWidthParam = maxWidth . Value . ToString ( UsCulture ) ;
vf + = string . Format ( ",scale=min(iw\\,{0}):trunc(ow/dar/2)*2" , maxWidthParam ) ;
}
2015-09-20 19:56:26 +02:00
FileSystem . CreateDirectory ( targetDirectory ) ;
2014-06-29 19:35:05 +02:00
var outputPath = Path . Combine ( targetDirectory , filenamePrefix + "%05d.jpg" ) ;
2016-08-10 21:15:41 +02:00
var args = string . Format ( "-i {0} -threads 0 -v quiet -vf \"{2}\" -f image2 \"{1}\"" , inputArgument , outputPath , vf ) ;
2014-06-29 19:35:05 +02:00
var probeSize = GetProbeSizeArgument ( new [ ] { inputArgument } , protocol ) ;
if ( ! string . IsNullOrEmpty ( probeSize ) )
{
args = probeSize + " " + args ;
}
var process = new Process
{
StartInfo = new ProcessStartInfo
{
CreateNoWindow = true ,
UseShellExecute = false ,
FileName = FFMpegPath ,
Arguments = args ,
WindowStyle = ProcessWindowStyle . Hidden ,
ErrorDialog = false ,
RedirectStandardInput = true
}
} ;
_logger . Info ( process . StartInfo . FileName + " " + process . StartInfo . Arguments ) ;
2015-01-02 07:12:58 +01:00
2014-06-29 19:35:05 +02:00
await resourcePool . WaitAsync ( cancellationToken ) . ConfigureAwait ( false ) ;
2015-04-15 17:41:42 +02:00
bool ranToCompletion = false ;
2015-01-31 20:44:26 +01:00
2016-08-03 06:33:34 +02:00
using ( var processWrapper = new ProcessWrapper ( process , this , _logger , true ) )
2015-01-31 20:44:26 +01:00
{
2015-05-06 14:56:26 +02:00
try
{
StartProcess ( processWrapper ) ;
2015-01-31 20:44:26 +01:00
2015-05-06 14:56:26 +02:00
// Need to give ffmpeg enough time to make all the thumbnails, which could be a while,
// but we still need to detect if the process hangs.
// Making the assumption that as long as new jpegs are showing up, everything is good.
2014-06-29 19:35:05 +02:00
2015-05-06 14:56:26 +02:00
bool isResponsive = true ;
int lastCount = 0 ;
2015-02-01 21:05:39 +01:00
2015-05-06 14:56:26 +02:00
while ( isResponsive )
2015-04-15 17:41:42 +02:00
{
2015-05-06 14:56:26 +02:00
if ( process . WaitForExit ( 30000 ) )
{
ranToCompletion = true ;
break ;
}
cancellationToken . ThrowIfCancellationRequested ( ) ;
2015-04-16 05:23:13 +02:00
2015-05-06 14:56:26 +02:00
var jpegCount = Directory . GetFiles ( targetDirectory )
. Count ( i = > string . Equals ( Path . GetExtension ( i ) , ".jpg" , StringComparison . OrdinalIgnoreCase ) ) ;
2014-06-29 19:35:05 +02:00
2015-05-06 14:56:26 +02:00
isResponsive = ( jpegCount > lastCount ) ;
lastCount = jpegCount ;
}
2014-06-29 19:35:05 +02:00
2015-05-06 14:56:26 +02:00
if ( ! ranToCompletion )
{
StopProcess ( processWrapper , 1000 , false ) ;
}
2014-06-29 19:35:05 +02:00
}
2015-05-06 14:56:26 +02:00
finally
2014-06-29 19:35:05 +02:00
{
2015-05-06 14:56:26 +02:00
resourcePool . Release ( ) ;
2014-06-29 19:35:05 +02:00
}
2015-05-06 14:56:26 +02:00
var exitCode = ranToCompletion ? processWrapper . ExitCode ? ? 0 : - 1 ;
2014-06-29 19:35:05 +02:00
2015-05-06 14:56:26 +02:00
if ( exitCode = = - 1 )
{
var msg = string . Format ( "ffmpeg image extraction failed for {0}" , inputArgument ) ;
2014-06-29 19:35:05 +02:00
2015-05-06 14:56:26 +02:00
_logger . Error ( msg ) ;
2014-06-29 19:35:05 +02:00
2015-05-06 14:56:26 +02:00
throw new ApplicationException ( msg ) ;
}
2014-06-29 19:35:05 +02:00
}
}
2015-01-02 06:36:27 +01:00
public async Task < string > EncodeAudio ( EncodingJobOptions options ,
IProgress < double > progress ,
CancellationToken cancellationToken )
{
2015-01-02 07:12:58 +01:00
var job = await new AudioEncoder ( this ,
_logger ,
ConfigurationManager ,
FileSystem ,
IsoManager ,
LibraryManager ,
SessionManager ,
2015-03-08 05:44:31 +01:00
SubtitleEncoder ( ) ,
MediaSourceManager ( ) )
2015-01-02 07:12:58 +01:00
. Start ( options , progress , cancellationToken ) . ConfigureAwait ( false ) ;
await job . TaskCompletionSource . Task . ConfigureAwait ( false ) ;
return job . OutputFilePath ;
}
public async Task < string > EncodeVideo ( EncodingJobOptions options ,
IProgress < double > progress ,
CancellationToken cancellationToken )
{
var job = await new VideoEncoder ( this ,
_logger ,
ConfigurationManager ,
FileSystem ,
IsoManager ,
LibraryManager ,
SessionManager ,
2015-03-08 05:44:31 +01:00
SubtitleEncoder ( ) ,
MediaSourceManager ( ) )
2015-01-02 06:36:27 +01:00
. Start ( options , progress , cancellationToken ) . ConfigureAwait ( false ) ;
await job . TaskCompletionSource . Task . ConfigureAwait ( false ) ;
return job . OutputFilePath ;
}
2015-04-10 16:01:16 +02:00
2015-04-11 19:59:55 +02:00
private void StartProcess ( ProcessWrapper process )
2015-04-10 16:01:16 +02:00
{
2015-04-11 19:59:55 +02:00
process . Process . Start ( ) ;
2015-04-10 16:01:16 +02:00
lock ( _runningProcesses )
{
_runningProcesses . Add ( process ) ;
}
}
2015-04-11 19:59:55 +02:00
private void StopProcess ( ProcessWrapper process , int waitTimeMs , bool enableForceKill )
2015-04-10 16:01:16 +02:00
{
try
{
_logger . Info ( "Killing ffmpeg process" ) ;
2016-08-03 06:33:34 +02:00
if ( process . IsRedirectingStdin )
2015-04-10 21:08:09 +02:00
{
2016-08-03 06:33:34 +02:00
try
{
process . Process . StandardInput . WriteLine ( "q" ) ;
}
catch ( Exception )
{
_logger . Error ( "Error sending q command to process" ) ;
}
2015-04-10 21:08:09 +02:00
}
2015-04-10 16:01:16 +02:00
2015-04-10 21:08:09 +02:00
try
2015-04-10 16:01:16 +02:00
{
2015-04-11 19:59:55 +02:00
if ( process . Process . WaitForExit ( waitTimeMs ) )
2015-04-10 16:01:16 +02:00
{
2015-04-10 21:08:09 +02:00
return ;
2015-04-10 16:01:16 +02:00
}
}
2015-04-10 21:08:09 +02:00
catch ( Exception ex )
{
_logger . Error ( "Error in WaitForExit" , ex ) ;
}
if ( enableForceKill )
{
2015-04-13 07:12:02 +02:00
process . Process . Kill ( ) ;
2015-04-10 21:08:09 +02:00
}
2015-04-10 16:01:16 +02:00
}
catch ( Exception ex )
{
_logger . ErrorException ( "Error killing process" , ex ) ;
}
}
private void StopProcesses ( )
{
2015-04-11 19:59:55 +02:00
List < ProcessWrapper > proceses ;
2015-04-10 16:01:16 +02:00
lock ( _runningProcesses )
{
proceses = _runningProcesses . ToList ( ) ;
}
2015-04-13 07:12:02 +02:00
_runningProcesses . Clear ( ) ;
2015-04-10 16:01:16 +02:00
foreach ( var process in proceses )
{
2015-04-13 07:12:02 +02:00
if ( ! process . HasExited )
{
StopProcess ( process , 500 , true ) ;
}
2015-04-10 16:01:16 +02:00
}
}
2015-08-16 17:53:30 +02:00
public string EscapeSubtitleFilterPath ( string path )
{
2015-08-16 18:23:11 +02:00
return path . Replace ( '\\' , '/' ) . Replace ( ":/" , "\\:/" ) . Replace ( "'" , "'\\\\\\''" ) ;
2015-08-16 17:53:30 +02:00
}
2015-04-10 16:01:16 +02:00
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
public void Dispose ( )
{
Dispose ( true ) ;
}
/// <summary>
/// Releases unmanaged and - optionally - managed resources.
/// </summary>
/// <param name="dispose"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
protected virtual void Dispose ( bool dispose )
{
if ( dispose )
{
_videoImageResourcePool . Dispose ( ) ;
StopProcesses ( ) ;
}
}
2015-04-11 19:59:55 +02:00
2015-05-06 14:56:26 +02:00
private class ProcessWrapper : IDisposable
2015-04-11 19:59:55 +02:00
{
public readonly Process Process ;
public bool HasExited ;
public int? ExitCode ;
private readonly MediaEncoder _mediaEncoder ;
2015-05-14 05:24:25 +02:00
private readonly ILogger _logger ;
2016-08-03 08:38:27 +02:00
public bool IsRedirectingStdin { get ; private set ; }
2015-04-11 19:59:55 +02:00
2016-08-03 06:33:34 +02:00
public ProcessWrapper ( Process process , MediaEncoder mediaEncoder , ILogger logger , bool isRedirectingStdin )
2015-04-11 19:59:55 +02:00
{
Process = process ;
2015-08-27 17:58:07 +02:00
_mediaEncoder = mediaEncoder ;
2015-05-14 05:24:25 +02:00
_logger = logger ;
2015-04-11 19:59:55 +02:00
Process . Exited + = Process_Exited ;
2016-08-03 06:33:34 +02:00
IsRedirectingStdin = isRedirectingStdin ;
2015-04-11 19:59:55 +02:00
}
void Process_Exited ( object sender , EventArgs e )
{
var process = ( Process ) sender ;
HasExited = true ;
2015-05-14 05:24:25 +02:00
try
{
ExitCode = process . ExitCode ;
}
2016-08-03 08:38:27 +02:00
catch
2015-05-14 05:24:25 +02:00
{
}
2015-04-11 19:59:55 +02:00
lock ( _mediaEncoder . _runningProcesses )
{
_mediaEncoder . _runningProcesses . Remove ( this ) ;
2015-04-13 07:12:02 +02:00
}
2016-08-03 08:38:27 +02:00
DisposeProcess ( process ) ;
}
private void DisposeProcess ( Process process )
{
2016-02-21 18:22:31 +01:00
try
{
process . Dispose ( ) ;
}
2016-08-03 08:38:27 +02:00
catch
2016-02-21 18:22:31 +01:00
{
}
2015-04-11 19:59:55 +02:00
}
2015-05-06 14:56:26 +02:00
private bool _disposed ;
private readonly object _syncLock = new object ( ) ;
public void Dispose ( )
{
lock ( _syncLock )
{
if ( ! _disposed )
{
if ( Process ! = null )
{
Process . Exited - = Process_Exited ;
2016-08-03 08:38:27 +02:00
DisposeProcess ( Process ) ;
2015-05-06 14:56:26 +02:00
}
}
_disposed = true ;
}
}
2015-04-11 19:59:55 +02:00
}
2013-04-07 22:55:05 +02:00
}
2015-09-20 19:56:26 +02:00
}