create separate media encoding project

5 files changed, 1286 insertions, 0 deletions

diff --git a/MediaBrowser.MediaEncoding/BdInfo/BdInfoExaminer.cs b/MediaBrowser.MediaEncoding/BdInfo/BdInfoExaminer.cs
new file mode 100644
index 000000000..b15b8d15d
--- /dev/null
+++ b/MediaBrowser.MediaEncoding/BdInfo/BdInfoExaminer.cs
@@ -0,0 +1,185 @@
+using BDInfo;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.MediaInfo;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace MediaBrowser.MediaEncoding.BdInfo
+{
+    /// <summary>
+    /// Class BdInfoExaminer
+    /// </summary>
+    public class BdInfoExaminer : IBlurayExaminer
+    {
+        /// <summary>
+        /// Gets the disc info.
+        /// </summary>
+        /// <param name="path">The path.</param>
+        /// <returns>BlurayDiscInfo.</returns>
+        public BlurayDiscInfo GetDiscInfo(string path)
+        {
+            var bdrom = new BDROM(path);
+
+            bdrom.Scan();
+
+            // Get the longest playlist
+            var playlist = bdrom.PlaylistFiles.Values.OrderByDescending(p => p.TotalLength).FirstOrDefault(p => p.IsValid);
+
+            var outputStream = new BlurayDiscInfo
+            {
+                MediaStreams = new List<MediaStream>()
+            };
+
+            if (playlist == null)
+            {
+                return outputStream;
+            }
+
+            outputStream.Chapters = playlist.Chapters;
+
+            outputStream.RunTimeTicks = TimeSpan.FromSeconds(playlist.TotalLength).Ticks;
+
+            var mediaStreams = new List<MediaStream> { };
+
+            foreach (var stream in playlist.SortedStreams)
+            {
+                var videoStream = stream as TSVideoStream;
+
+                if (videoStream != null)
+                {
+                    AddVideoStream(mediaStreams, videoStream);
+                    continue;
+                }
+
+                var audioStream = stream as TSAudioStream;
+
+                if (audioStream != null)
+                {
+                    AddAudioStream(mediaStreams, audioStream);
+                    continue;
+                }
+
+                var textStream = stream as TSTextStream;
+
+                if (textStream != null)
+                {
+                    AddSubtitleStream(mediaStreams, textStream);
+                    continue;
+                }
+
+                var graphicsStream = stream as TSGraphicsStream;
+
+                if (graphicsStream != null)
+                {
+                    AddSubtitleStream(mediaStreams, graphicsStream);
+                }
+            }
+
+            outputStream.MediaStreams = mediaStreams;
+
+            outputStream.PlaylistName = playlist.Name;
+
+            if (playlist.StreamClips != null && playlist.StreamClips.Any())
+            {
+                // Get the files in the playlist
+                outputStream.Files = playlist.StreamClips.Select(i => i.StreamFile.Name).ToList();
+            }
+
+            return outputStream;
+        }
+
+        /// <summary>
+        /// Adds the video stream.
+        /// </summary>
+        /// <param name="streams">The streams.</param>
+        /// <param name="videoStream">The video stream.</param>
+        private void AddVideoStream(List<MediaStream> streams, TSVideoStream videoStream)
+        {
+            var mediaStream = new MediaStream
+            {
+                BitRate = Convert.ToInt32(videoStream.BitRate),
+                Width = videoStream.Width,
+                Height = videoStream.Height,
+                Codec = videoStream.CodecShortName,
+                IsInterlaced = videoStream.IsInterlaced,
+                Type = MediaStreamType.Video,
+                Index = streams.Count
+            };
+
+            if (videoStream.FrameRateDenominator > 0)
+            {
+                float frameRateEnumerator = videoStream.FrameRateEnumerator;
+                float frameRateDenominator = videoStream.FrameRateDenominator;
+
+                mediaStream.AverageFrameRate = mediaStream.RealFrameRate = frameRateEnumerator / frameRateDenominator;
+            }
+
+            streams.Add(mediaStream);
+        }
+
+        /// <summary>
+        /// Adds the audio stream.
+        /// </summary>
+        /// <param name="streams">The streams.</param>
+        /// <param name="audioStream">The audio stream.</param>
+        private void AddAudioStream(List<MediaStream> streams, TSAudioStream audioStream)
+        {
+            var stream = new MediaStream
+            {
+                Codec = audioStream.CodecShortName,
+                Language = audioStream.LanguageCode,
+                Channels = audioStream.ChannelCount,
+                SampleRate = audioStream.SampleRate,
+                Type = MediaStreamType.Audio,
+                Index = streams.Count
+            };
+
+            var bitrate = Convert.ToInt32(audioStream.BitRate);
+
+            if (bitrate > 0)
+            {
+                stream.BitRate = bitrate;
+            }
+
+            if (audioStream.LFE > 0)
+            {
+                stream.Channels = audioStream.ChannelCount + 1;
+            }
+
+            streams.Add(stream);
+        }
+
+        /// <summary>
+        /// Adds the subtitle stream.
+        /// </summary>
+        /// <param name="streams">The streams.</param>
+        /// <param name="textStream">The text stream.</param>
+        private void AddSubtitleStream(List<MediaStream> streams, TSTextStream textStream)
+        {
+            streams.Add(new MediaStream
+            {
+                Language = textStream.LanguageCode,
+                Codec = textStream.CodecShortName,
+                Type = MediaStreamType.Subtitle,
+                Index = streams.Count
+            });
+        }
+
+        /// <summary>
+        /// Adds the subtitle stream.
+        /// </summary>
+        /// <param name="streams">The streams.</param>
+        /// <param name="textStream">The text stream.</param>
+        private void AddSubtitleStream(List<MediaStream> streams, TSGraphicsStream textStream)
+        {
+            streams.Add(new MediaStream
+                {
+                    Language = textStream.LanguageCode,
+                    Codec = textStream.CodecShortName,
+                    Type = MediaStreamType.Subtitle,
+                    Index = streams.Count
+                });
+        }
+    }
+}
diff --git a/MediaBrowser.MediaEncoding/Encoder/MediaEncoder.cs b/MediaBrowser.MediaEncoding/Encoder/MediaEncoder.cs
new file mode 100644
index 000000000..7cabf23c4
--- /dev/null
+++ b/MediaBrowser.MediaEncoding/Encoder/MediaEncoder.cs
@@ -0,0 +1,981 @@
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Common.IO;
+using MediaBrowser.Controller.MediaEncoding;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Logging;
+using MediaBrowser.Model.Serialization;
+using System;
+using System.Collections.Concurrent;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Globalization;
+using System.IO;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MediaBrowser.MediaEncoding.Encoder
+{
+    /// <summary>
+    /// Class MediaEncoder
+    /// </summary>
+    public class MediaEncoder : IMediaEncoder, IDisposable
+    {
+        /// <summary>
+        /// The _logger
+        /// </summary>
+        private readonly ILogger _logger;
+
+        /// <summary>
+        /// The _app paths
+        /// </summary>
+        private readonly IApplicationPaths _appPaths;
+
+        /// <summary>
+        /// Gets the json serializer.
+        /// </summary>
+        /// <value>The json serializer.</value>
+        private readonly IJsonSerializer _jsonSerializer;
+
+        /// <summary>
+        /// The video image resource pool
+        /// </summary>
+        private readonly SemaphoreSlim _videoImageResourcePool = new SemaphoreSlim(1, 1);
+
+        /// <summary>
+        /// The audio image resource pool
+        /// </summary>
+        private readonly SemaphoreSlim _audioImageResourcePool = new SemaphoreSlim(2, 2);
+
+        /// <summary>
+        /// The FF probe resource pool
+        /// </summary>
+        private readonly SemaphoreSlim _ffProbeResourcePool = new SemaphoreSlim(2, 2);
+
+        private readonly IFileSystem _fileSystem;
+
+        public string FFMpegPath { get; private set; }
+
+        public string FFProbePath { get; private set; }
+
+        public string Version { get; private set; }
+
+        public MediaEncoder(ILogger logger, IApplicationPaths appPaths,
+            IJsonSerializer jsonSerializer, string ffMpegPath, string ffProbePath, string version,
+            IFileSystem fileSystem)
+        {
+            _logger = logger;
+            _appPaths = appPaths;
+            _jsonSerializer = jsonSerializer;
+            Version = version;
+            _fileSystem = fileSystem;
+            FFProbePath = ffProbePath;
+            FFMpegPath = ffMpegPath;
+        }
+
+        /// <summary>
+        /// Gets the encoder path.
+        /// </summary>
+        /// <value>The encoder path.</value>
+        public string EncoderPath
+        {
+            get { return FFMpegPath; }
+        }
+
+        /// <summary>
+        /// The _semaphoreLocks
+        /// </summary>
+        private readonly ConcurrentDictionary<string, SemaphoreSlim> _semaphoreLocks =
+            new ConcurrentDictionary<string, SemaphoreSlim>();
+
+        /// <summary>
+        /// Gets the lock.
+        /// </summary>
+        /// <param name="filename">The filename.</param>
+        /// <returns>System.Object.</returns>
+        private SemaphoreSlim GetLock(string filename)
+        {
+            return _semaphoreLocks.GetOrAdd(filename, key => new SemaphoreSlim(1, 1));
+        }
+
+        /// <summary>
+        /// Gets the media info.
+        /// </summary>
+        /// <param name="inputFiles">The input files.</param>
+        /// <param name="type">The type.</param>
+        /// <param name="isAudio">if set to <c>true</c> [is audio].</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task.</returns>
+        public Task<InternalMediaInfoResult> GetMediaInfo(string[] inputFiles, InputType type, bool isAudio,
+            CancellationToken cancellationToken)
+        {
+            return GetMediaInfoInternal(GetInputArgument(inputFiles, type), !isAudio,
+                GetProbeSizeArgument(type), cancellationToken);
+        }
+
+        /// <summary>
+        /// Gets the input argument.
+        /// </summary>
+        /// <param name="inputFiles">The input files.</param>
+        /// <param name="type">The type.</param>
+        /// <returns>System.String.</returns>
+        /// <exception cref="System.ArgumentException">Unrecognized InputType</exception>
+        public string GetInputArgument(string[] inputFiles, InputType type)
+        {
+            string inputPath;
+
+            switch (type)
+            {
+                case InputType.Bluray:
+                case InputType.Dvd:
+                case InputType.File:
+                    inputPath = GetConcatInputArgument(inputFiles);
+                    break;
+                case InputType.Url:
+                    inputPath = GetHttpInputArgument(inputFiles);
+                    break;
+                default:
+                    throw new ArgumentException("Unrecognized InputType");
+            }
+
+            return inputPath;
+        }
+
+        /// <summary>
+        /// Gets the HTTP input argument.
+        /// </summary>
+        /// <param name="inputFiles">The input files.</param>
+        /// <returns>System.String.</returns>
+        private string GetHttpInputArgument(string[] inputFiles)
+        {
+            var url = inputFiles[0];
+
+            return string.Format("\"{0}\"", url);
+        }
+
+        /// <summary>
+        /// Gets the probe size argument.
+        /// </summary>
+        /// <param name="type">The type.</param>
+        /// <returns>System.String.</returns>
+        public string GetProbeSizeArgument(InputType type)
+        {
+            return type == InputType.Dvd ? "-probesize 1G -analyzeduration 200M" : string.Empty;
+        }
+
+        /// <summary>
+        /// Gets the media info internal.
+        /// </summary>
+        /// <param name="inputPath">The input path.</param>
+        /// <param name="extractChapters">if set to <c>true</c> [extract chapters].</param>
+        /// <param name="probeSizeArgument">The probe size argument.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task{MediaInfoResult}.</returns>
+        /// <exception cref="System.ApplicationException"></exception>
+        private async Task<InternalMediaInfoResult> GetMediaInfoInternal(string inputPath, bool extractChapters,
+            string probeSizeArgument,
+            CancellationToken cancellationToken)
+        {
+            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";
+
+            var process = new Process
+            {
+                StartInfo = new ProcessStartInfo
+                {
+                    CreateNoWindow = true,
+                    UseShellExecute = false,
+
+                    // Must consume both or ffmpeg may hang due to deadlocks. See comments below.   
+                    RedirectStandardOutput = true,
+                    RedirectStandardError = true,
+                    FileName = FFProbePath,
+                    Arguments = string.Format(args,
+                        probeSizeArgument, inputPath).Trim(),
+
+                    WindowStyle = ProcessWindowStyle.Hidden,
+                    ErrorDialog = false
+                },
+
+                EnableRaisingEvents = true
+            };
+
+            _logger.Debug("{0} {1}", process.StartInfo.FileName, process.StartInfo.Arguments);
+
+            process.Exited += ProcessExited;
+
+            await _ffProbeResourcePool.WaitAsync(cancellationToken).ConfigureAwait(false);
+
+            InternalMediaInfoResult result;
+
+            try
+            {
+                process.Start();
+            }
+            catch (Exception ex)
+            {
+                _ffProbeResourcePool.Release();
+
+                _logger.ErrorException("Error starting ffprobe", ex);
+
+                throw;
+            }
+
+            try
+            {
+                process.BeginErrorReadLine();
+
+                result =
+                    _jsonSerializer.DeserializeFromStream<InternalMediaInfoResult>(process.StandardOutput.BaseStream);
+            }
+            catch
+            {
+                // Hate having to do this
+                try
+                {
+                    process.Kill();
+                }
+                catch (Exception ex1)
+                {
+                    _logger.ErrorException("Error killing ffprobe", ex1);
+                }
+
+                throw;
+            }
+            finally
+            {
+                _ffProbeResourcePool.Release();
+            }
+
+            if (result == null)
+            {
+                throw new ApplicationException(string.Format("FFProbe failed for {0}", inputPath));
+            }
+
+            cancellationToken.ThrowIfCancellationRequested();
+
+            if (result.streams != null)
+            {
+                // Normalize aspect ratio if invalid
+                foreach (var stream in result.streams)
+                {
+                    if (string.Equals(stream.display_aspect_ratio, "0:1", StringComparison.OrdinalIgnoreCase))
+                    {
+                        stream.display_aspect_ratio = string.Empty;
+                    }
+                    if (string.Equals(stream.sample_aspect_ratio, "0:1", StringComparison.OrdinalIgnoreCase))
+                    {
+                        stream.sample_aspect_ratio = string.Empty;
+                    }
+                }
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// The us culture
+        /// </summary>
+        protected readonly CultureInfo UsCulture = new CultureInfo("en-US");
+
+        /// <summary>
+        /// Processes the exited.
+        /// </summary>
+        /// <param name="sender">The sender.</param>
+        /// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
+        private void ProcessExited(object sender, EventArgs e)
+        {
+            ((Process)sender).Dispose();
+        }
+
+        /// <summary>
+        /// Converts the text subtitle to ass.
+        /// </summary>
+        /// <param name="inputPath">The input path.</param>
+        /// <param name="outputPath">The output path.</param>
+        /// <param name="language">The language.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task.</returns>
+        public async Task ConvertTextSubtitleToAss(string inputPath, string outputPath, string language,
+            CancellationToken cancellationToken)
+        {
+            var semaphore = GetLock(outputPath);
+
+            await semaphore.WaitAsync(cancellationToken).ConfigureAwait(false);
+
+            try
+            {
+                if (!File.Exists(outputPath))
+                {
+                    await ConvertTextSubtitleToAssInternal(inputPath, outputPath, language).ConfigureAwait(false);
+                }
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        private const int FastSeekOffsetSeconds = 1;
+
+        /// <summary>
+        /// Converts the text subtitle to ass.
+        /// </summary>
+        /// <param name="inputPath">The input path.</param>
+        /// <param name="outputPath">The output path.</param>
+        /// <param name="language">The language.</param>
+        /// <returns>Task.</returns>
+        /// <exception cref="System.ArgumentNullException">inputPath
+        /// or
+        /// outputPath</exception>
+        /// <exception cref="System.ApplicationException"></exception>
+        private async Task ConvertTextSubtitleToAssInternal(string inputPath, string outputPath, string language)
+        {
+            if (string.IsNullOrEmpty(inputPath))
+            {
+                throw new ArgumentNullException("inputPath");
+            }
+
+            if (string.IsNullOrEmpty(outputPath))
+            {
+                throw new ArgumentNullException("outputPath");
+            }
+
+
+            var encodingParam = string.IsNullOrEmpty(language)
+                ? string.Empty
+                : GetSubtitleLanguageEncodingParam(language) + " ";
+
+            var process = new Process
+            {
+                StartInfo = new ProcessStartInfo
+                {
+                    RedirectStandardOutput = false,
+                    RedirectStandardError = true,
+
+                    CreateNoWindow = true,
+                    UseShellExecute = false,
+                    FileName = FFMpegPath,
+                    Arguments =
+                        string.Format("{0} -i \"{1}\" -c:s ass \"{2}\"", encodingParam, inputPath, outputPath),
+
+                    WindowStyle = ProcessWindowStyle.Hidden,
+                    ErrorDialog = false
+                }
+            };
+
+            _logger.Debug("{0} {1}", process.StartInfo.FileName, process.StartInfo.Arguments);
+
+            var logFilePath = Path.Combine(_appPaths.LogDirectoryPath, "ffmpeg-sub-convert-" + Guid.NewGuid() + ".txt");
+            Directory.CreateDirectory(Path.GetDirectoryName(logFilePath));
+
+            var logFileStream = _fileSystem.GetFileStream(logFilePath, FileMode.Create, FileAccess.Write, FileShare.Read,
+                true);
+
+            try
+            {
+                process.Start();
+            }
+            catch (Exception ex)
+            {
+                logFileStream.Dispose();
+
+                _logger.ErrorException("Error starting ffmpeg", ex);
+
+                throw;
+            }
+
+            var logTask = process.StandardError.BaseStream.CopyToAsync(logFileStream);
+
+            var ranToCompletion = process.WaitForExit(60000);
+
+            if (!ranToCompletion)
+            {
+                try
+                {
+                    _logger.Info("Killing ffmpeg subtitle conversion process");
+
+                    process.Kill();
+
+                    process.WaitForExit(1000);
+
+                    await logTask.ConfigureAwait(false);
+                }
+                catch (Exception ex)
+                {
+                    _logger.ErrorException("Error killing subtitle conversion process", ex);
+                }
+                finally
+                {
+                    logFileStream.Dispose();
+                }
+            }
+
+            var exitCode = ranToCompletion ? process.ExitCode : -1;
+
+            process.Dispose();
+
+            var failed = false;
+
+            if (exitCode == -1)
+            {
+                failed = true;
+
+                if (File.Exists(outputPath))
+                {
+                    try
+                    {
+                        _logger.Info("Deleting converted subtitle due to failure: ", outputPath);
+                        File.Delete(outputPath);
+                    }
+                    catch (IOException ex)
+                    {
+                        _logger.ErrorException("Error deleting converted subtitle {0}", ex, outputPath);
+                    }
+                }
+            }
+            else if (!File.Exists(outputPath))
+            {
+                failed = true;
+            }
+
+            if (failed)
+            {
+                var msg = string.Format("ffmpeg subtitle converted failed for {0}", inputPath);
+
+                _logger.Error(msg);
+
+                throw new ApplicationException(msg);
+            }
+            await SetAssFont(outputPath).ConfigureAwait(false);
+        }
+
+        protected string GetFastSeekCommandLineParameter(TimeSpan offset)
+        {
+            var seconds = offset.TotalSeconds - FastSeekOffsetSeconds;
+
+            if (seconds > 0)
+            {
+                return string.Format("-ss {0} ", seconds.ToString(UsCulture));
+            }
+
+            return string.Empty;
+        }
+
+        protected string GetSlowSeekCommandLineParameter(TimeSpan offset)
+        {
+            if (offset.TotalSeconds - FastSeekOffsetSeconds > 0)
+            {
+                return string.Format(" -ss {0}", FastSeekOffsetSeconds.ToString(UsCulture));
+            }
+
+            return string.Empty;
+        }
+
+        /// <summary>
+        /// Gets the subtitle language encoding param.
+        /// </summary>
+        /// <param name="language">The language.</param>
+        /// <returns>System.String.</returns>
+        private string GetSubtitleLanguageEncodingParam(string language)
+        {
+            switch (language.ToLower())
+            {
+                case "pol":
+                case "cze":
+                case "ces":
+                case "slo":
+                case "slk":
+                case "hun":
+                case "slv":
+                case "srp":
+                case "hrv":
+                case "rum":
+                case "ron":
+                case "rup":
+                case "alb":
+                case "sqi":
+                    return "-sub_charenc windows-1250";
+                case "ara":
+                    return "-sub_charenc windows-1256";
+                case "heb":
+                    return "-sub_charenc windows-1255";
+                case "grc":
+                case "gre":
+                    return "-sub_charenc windows-1253";
+                case "crh":
+                case "ota":
+                case "tur":
+                    return "-sub_charenc windows-1254";
+                case "rus":
+                    return "-sub_charenc windows-1251";
+                case "vie":
+                    return "-sub_charenc windows-1258";
+                case "kor":
+                    return "-sub_charenc cp949";
+                default:
+                    return "-sub_charenc windows-1252";
+            }
+        }
+
+        /// <summary>
+        /// Extracts the text subtitle.
+        /// </summary>
+        /// <param name="inputFiles">The input files.</param>
+        /// <param name="type">The type.</param>
+        /// <param name="subtitleStreamIndex">Index of the subtitle stream.</param>
+        /// <param name="copySubtitleStream">if set to true, copy stream instead of converting.</param>
+        /// <param name="outputPath">The output path.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task.</returns>
+        /// <exception cref="System.ArgumentException">Must use inputPath list overload</exception>
+        public async Task ExtractTextSubtitle(string[] inputFiles, InputType type, int subtitleStreamIndex,
+            bool copySubtitleStream, string outputPath, CancellationToken cancellationToken)
+        {
+            var semaphore = GetLock(outputPath);
+
+            await semaphore.WaitAsync(cancellationToken).ConfigureAwait(false);
+
+            try
+            {
+                if (!File.Exists(outputPath))
+                {
+                    await
+                        ExtractTextSubtitleInternal(GetInputArgument(inputFiles, type), subtitleStreamIndex,
+                            copySubtitleStream, outputPath, cancellationToken).ConfigureAwait(false);
+                }
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Extracts the text subtitle.
+        /// </summary>
+        /// <param name="inputPath">The input path.</param>
+        /// <param name="subtitleStreamIndex">Index of the subtitle stream.</param>
+        /// <param name="copySubtitleStream">if set to true, copy stream instead of converting.</param>
+        /// <param name="outputPath">The output path.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task.</returns>
+        /// <exception cref="System.ArgumentNullException">inputPath
+        /// or
+        /// outputPath
+        /// or
+        /// cancellationToken</exception>
+        /// <exception cref="System.ApplicationException"></exception>
+        private async Task ExtractTextSubtitleInternal(string inputPath, int subtitleStreamIndex,
+            bool copySubtitleStream, string outputPath, CancellationToken cancellationToken)
+        {
+            if (string.IsNullOrEmpty(inputPath))
+            {
+                throw new ArgumentNullException("inputPath");
+            }
+
+            if (string.IsNullOrEmpty(outputPath))
+            {
+                throw new ArgumentNullException("outputPath");
+            }
+
+            string processArgs = string.Format("-i {0} -map 0:{1} -an -vn -c:s ass \"{2}\"", inputPath,
+                subtitleStreamIndex, outputPath);
+
+            if (copySubtitleStream)
+            {
+                processArgs = string.Format("-i {0} -map 0:{1} -an -vn -c:s copy \"{2}\"", inputPath,
+                    subtitleStreamIndex, outputPath);
+            }
+
+            var process = new Process
+            {
+                StartInfo = new ProcessStartInfo
+                {
+                    CreateNoWindow = true,
+                    UseShellExecute = false,
+
+                    RedirectStandardOutput = false,
+                    RedirectStandardError = true,
+
+                    FileName = FFMpegPath,
+                    Arguments = processArgs,
+                    WindowStyle = ProcessWindowStyle.Hidden,
+                    ErrorDialog = false
+                }
+            };
+
+            _logger.Debug("{0} {1}", process.StartInfo.FileName, process.StartInfo.Arguments);
+
+            var logFilePath = Path.Combine(_appPaths.LogDirectoryPath, "ffmpeg-sub-extract-" + Guid.NewGuid() + ".txt");
+            Directory.CreateDirectory(Path.GetDirectoryName(logFilePath));
+
+            var logFileStream = _fileSystem.GetFileStream(logFilePath, FileMode.Create, FileAccess.Write, FileShare.Read,
+                true);
+
+            try
+            {
+                process.Start();
+            }
+            catch (Exception ex)
+            {
+                logFileStream.Dispose();
+
+                _logger.ErrorException("Error starting ffmpeg", ex);
+
+                throw;
+            }
+
+            process.StandardError.BaseStream.CopyToAsync(logFileStream);
+
+            var ranToCompletion = process.WaitForExit(60000);
+
+            if (!ranToCompletion)
+            {
+                try
+                {
+                    _logger.Info("Killing ffmpeg subtitle extraction process");
+
+                    process.Kill();
+
+                    process.WaitForExit(1000);
+                }
+                catch (Exception ex)
+                {
+                    _logger.ErrorException("Error killing subtitle extraction process", ex);
+                }
+                finally
+                {
+                    logFileStream.Dispose();
+                }
+            }
+
+            var exitCode = ranToCompletion ? process.ExitCode : -1;
+
+            process.Dispose();
+
+            var failed = false;
+
+            if (exitCode == -1)
+            {
+                failed = true;
+
+                if (File.Exists(outputPath))
+                {
+                    try
+                    {
+                        _logger.Info("Deleting extracted subtitle due to failure: ", outputPath);
+                        File.Delete(outputPath);
+                    }
+                    catch (IOException ex)
+                    {
+                        _logger.ErrorException("Error deleting extracted subtitle {0}", ex, outputPath);
+                    }
+                }
+            }
+            else if (!File.Exists(outputPath))
+            {
+                failed = true;
+            }
+
+            if (failed)
+            {
+                var msg = string.Format("ffmpeg subtitle extraction failed for {0} to {1}", inputPath, outputPath);
+
+                _logger.Error(msg);
+
+                throw new ApplicationException(msg);
+            }
+            else
+            {
+                var msg = string.Format("ffmpeg subtitle extraction completed for {0} to {1}", inputPath, outputPath);
+
+                _logger.Info(msg);
+            }
+
+            await SetAssFont(outputPath).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Sets the ass font.
+        /// </summary>
+        /// <param name="file">The file.</param>
+        /// <returns>Task.</returns>
+        private async Task SetAssFont(string file)
+        {
+            _logger.Info("Setting ass font within {0}", file);
+
+            string text;
+            Encoding encoding;
+
+            using (var reader = new StreamReader(file, detectEncodingFromByteOrderMarks: true))
+            {
+                encoding = reader.CurrentEncoding;
+
+                text = await reader.ReadToEndAsync().ConfigureAwait(false);
+            }
+
+            var newText = text.Replace(",Arial,", ",Arial Unicode MS,");
+
+            if (!string.Equals(text, newText))
+            {
+                using (var writer = new StreamWriter(file, false, encoding))
+                {
+                    writer.Write(newText);
+                }
+            }
+        }
+
+        public Task<Stream> ExtractAudioImage(string path, CancellationToken cancellationToken)
+        {
+            return ExtractImage(new[] { path }, InputType.File, true, null, null, cancellationToken);
+        }
+
+        public Task<Stream> ExtractVideoImage(string[] inputFiles, InputType type, Video3DFormat? threedFormat,
+            TimeSpan? offset, CancellationToken cancellationToken)
+        {
+            return ExtractImage(inputFiles, type, false, threedFormat, offset, cancellationToken);
+        }
+
+        private async Task<Stream> ExtractImage(string[] inputFiles, InputType type, bool isAudio,
+            Video3DFormat? threedFormat, TimeSpan? offset, CancellationToken cancellationToken)
+        {
+            var resourcePool = isAudio ? _audioImageResourcePool : _videoImageResourcePool;
+
+            var inputArgument = GetInputArgument(inputFiles, type);
+
+            if (!isAudio)
+            {
+                try
+                {
+                    return await ExtractImageInternal(inputArgument, type, threedFormat, offset, true, resourcePool, cancellationToken).ConfigureAwait(false);
+                }
+                catch
+                {
+                    _logger.Error("I-frame image extraction failed, will attempt standard way. Input: {0}", inputArgument);
+                }
+            }
+
+            return await ExtractImageInternal(inputArgument, type, threedFormat, offset, false, resourcePool, cancellationToken).ConfigureAwait(false);
+        }
+
+        private async Task<Stream> ExtractImageInternal(string inputPath, InputType type, Video3DFormat? threedFormat, TimeSpan? offset, bool useIFrame, SemaphoreSlim resourcePool, CancellationToken cancellationToken)
+        {
+            if (string.IsNullOrEmpty(inputPath))
+            {
+                throw new ArgumentNullException("inputPath");
+            }
+
+            // 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
+            var vf = "scale=600:trunc(600/dar/2)*2";
+            //crop=min(iw\,ih*dar):min(ih\,iw/dar):(iw-min(iw\,iw*sar))/2:(ih - min (ih\,ih/sar))/2,scale=600:(600/dar),thumbnail" -f image2
+
+            if (threedFormat.HasValue)
+            {
+                switch (threedFormat.Value)
+                {
+                    case Video3DFormat.HalfSideBySide:
+                        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";
+                        // 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:
+                        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";
+                        //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:
+                        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";
+                        //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:
+                        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";
+                        // ftab crop heigt in half, set the display aspect,crop out any black bars we may have made the scale width to 600
+                        break;
+                }
+            }
+
+            // 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.
+            var args = useIFrame ? string.Format("-i {0} -threads 0 -v quiet -vframes 1 -vf \"{2},thumbnail=80\" -f image2 \"{1}\"", inputPath, "-", vf) :
+                string.Format("-i {0} -threads 0 -v quiet -vframes 1 -vf \"{2}\" -f image2 \"{1}\"", inputPath, "-", vf);
+
+            var probeSize = GetProbeSizeArgument(type);
+
+            if (!string.IsNullOrEmpty(probeSize))
+            {
+                args = probeSize + " " + args;
+            }
+
+            if (offset.HasValue)
+            {
+                args = string.Format("-ss {0} ", Convert.ToInt32(offset.Value.TotalSeconds)).ToString(UsCulture) + args;
+            }
+
+            var process = new Process
+            {
+                StartInfo = new ProcessStartInfo
+                {
+                    CreateNoWindow = true,
+                    UseShellExecute = false,
+                    FileName = FFMpegPath,
+                    Arguments = args,
+                    WindowStyle = ProcessWindowStyle.Hidden,
+                    ErrorDialog = false,
+                    RedirectStandardOutput = true,
+                    RedirectStandardError = true
+                }
+            };
+
+            await resourcePool.WaitAsync(cancellationToken).ConfigureAwait(false);
+
+            process.Start();
+
+            var memoryStream = new MemoryStream();
+
+#pragma warning disable 4014
+            // Important - don't await the log task or we won't be able to kill ffmpeg when the user stops playback
+            process.StandardOutput.BaseStream.CopyToAsync(memoryStream);
+#pragma warning restore 4014
+
+            // MUST read both stdout and stderr asynchronously or a deadlock may occurr
+            process.BeginErrorReadLine();
+
+            var ranToCompletion = process.WaitForExit(10000);
+
+            if (!ranToCompletion)
+            {
+                try
+                {
+                    _logger.Info("Killing ffmpeg process");
+
+                    process.Kill();
+
+                    process.WaitForExit(1000);
+                }
+                catch (Exception ex)
+                {
+                    _logger.ErrorException("Error killing process", ex);
+                }
+            }
+
+            resourcePool.Release();
+
+            var exitCode = ranToCompletion ? process.ExitCode : -1;
+
+            process.Dispose();
+
+            if (exitCode == -1 || memoryStream.Length == 0)
+            {
+                memoryStream.Dispose();
+
+                var msg = string.Format("ffmpeg image extraction failed for {0}", inputPath);
+
+                _logger.Error(msg);
+
+                throw new ApplicationException(msg);
+            }
+
+            memoryStream.Position = 0;
+            return memoryStream;
+        }
+
+        /// <summary>
+        /// Starts the and wait for process.
+        /// </summary>
+        /// <param name="process">The process.</param>
+        /// <param name="timeout">The timeout.</param>
+        /// <returns><c>true</c> if XXXX, <c>false</c> otherwise</returns>
+        private bool StartAndWaitForProcess(Process process, int timeout = 10000)
+        {
+            process.Start();
+
+            var ranToCompletion = process.WaitForExit(timeout);
+
+            if (!ranToCompletion)
+            {
+                try
+                {
+                    _logger.Info("Killing ffmpeg process");
+
+                    process.Kill();
+
+                    process.WaitForExit(1000);
+                }
+                catch (Win32Exception ex)
+                {
+                    _logger.ErrorException("Error killing process", ex);
+                }
+                catch (InvalidOperationException ex)
+                {
+                    _logger.ErrorException("Error killing process", ex);
+                }
+                catch (NotSupportedException ex)
+                {
+                    _logger.ErrorException("Error killing process", ex);
+                }
+            }
+
+            return ranToCompletion;
+        }
+
+        /// <summary>
+        /// Gets the file input argument.
+        /// </summary>
+        /// <param name="path">The path.</param>
+        /// <returns>System.String.</returns>
+        private string GetFileInputArgument(string path)
+        {
+            return string.Format("file:\"{0}\"", path);
+        }
+
+        /// <summary>
+        /// Gets the concat input argument.
+        /// </summary>
+        /// <param name="playableStreamFiles">The playable stream files.</param>
+        /// <returns>System.String.</returns>
+        private string GetConcatInputArgument(string[] playableStreamFiles)
+        {
+            // Get all streams
+            // If there's more than one we'll need to use the concat command
+            if (playableStreamFiles.Length > 1)
+            {
+                var files = string.Join("|", playableStreamFiles);
+
+                return string.Format("concat:\"{0}\"", files);
+            }
+
+            // Determine the input path for video files
+            return GetFileInputArgument(playableStreamFiles[0]);
+        }
+
+        /// <summary>
+        /// Gets the bluray input argument.
+        /// </summary>
+        /// <param name="blurayRoot">The bluray root.</param>
+        /// <returns>System.String.</returns>
+        private string GetBlurayInputArgument(string blurayRoot)
+        {
+            return string.Format("bluray:\"{0}\"", blurayRoot);
+        }
+
+        /// <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();
+            }
+        }
+    }
+}
diff --git a/MediaBrowser.MediaEncoding/MediaBrowser.MediaEncoding.csproj b/MediaBrowser.MediaEncoding/MediaBrowser.MediaEncoding.csproj
new file mode 100644
index 000000000..d92522bf0
--- /dev/null
+++ b/MediaBrowser.MediaEncoding/MediaBrowser.MediaEncoding.csproj
@@ -0,0 +1,80 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{0BD82FA6-EB8A-4452-8AF5-74F9C3849451}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>MediaBrowser.MediaEncoding</RootNamespace>
+    <AssemblyName>MediaBrowser.MediaEncoding</AssemblyName>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\</SolutionDir>
+    <RestorePackages>true</RestorePackages>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="BDInfo">
+      <HintPath>..\packages\MediaBrowser.BdInfo.1.0.0.10\lib\net35\BDInfo.dll</HintPath>
+    </Reference>
+    <Reference Include="DvdLib">
+      <HintPath>..\packages\MediaBrowser.BdInfo.1.0.0.10\lib\net35\DvdLib.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="BdInfo\BdInfoExaminer.cs" />
+    <Compile Include="Encoder\MediaEncoder.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\MediaBrowser.Common\MediaBrowser.Common.csproj">
+      <Project>{9142eefa-7570-41e1-bfcc-468bb571af2f}</Project>
+      <Name>MediaBrowser.Common</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\MediaBrowser.Controller\MediaBrowser.Controller.csproj">
+      <Project>{17e1f4e6-8abd-4fe5-9ecf-43d4b6087ba2}</Project>
+      <Name>MediaBrowser.Controller</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\MediaBrowser.Model\MediaBrowser.Model.csproj">
+      <Project>{7eeeb4bb-f3e8-48fc-b4c5-70f0fff8329b}</Project>
+      <Name>MediaBrowser.Model</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <Import Project="$(SolutionDir)\.nuget\NuGet.targets" Condition="Exists('$(SolutionDir)\.nuget\NuGet.targets')" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
\ No newline at end of file
diff --git a/MediaBrowser.MediaEncoding/Properties/AssemblyInfo.cs b/MediaBrowser.MediaEncoding/Properties/AssemblyInfo.cs
new file mode 100644
index 000000000..6616e46ac
--- /dev/null
+++ b/MediaBrowser.MediaEncoding/Properties/AssemblyInfo.cs
@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("MediaBrowser.MediaEncoding")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("MediaBrowser.MediaEncoding")]
+[assembly: AssemblyCopyright("Copyright ©  2014")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("05f49ab9-2a90-4332-9d41-7817a9cccd90")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/MediaBrowser.MediaEncoding/packages.config b/MediaBrowser.MediaEncoding/packages.config
new file mode 100644
index 000000000..6e52b72b8
--- /dev/null
+++ b/MediaBrowser.MediaEncoding/packages.config
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="MediaBrowser.BdInfo" version="1.0.0.10" targetFramework="net45" />
+</packages>
\ No newline at end of file