|
|
@@ -1,19 +1,11 @@
|
|
|
-using System.Text;
|
|
|
-using MediaBrowser.Common.IO;
|
|
|
+using MediaBrowser.Common.IO;
|
|
|
+using MediaBrowser.Common.MediaInfo;
|
|
|
using MediaBrowser.Controller.Entities;
|
|
|
-using MediaBrowser.Controller.Entities.Audio;
|
|
|
+using MediaBrowser.Controller.Providers.MediaInfo;
|
|
|
using MediaBrowser.Model.Entities;
|
|
|
-using MediaBrowser.Model.IO;
|
|
|
-using MediaBrowser.Model.Logging;
|
|
|
-using MediaBrowser.Model.Serialization;
|
|
|
using System;
|
|
|
-using System.Collections.Generic;
|
|
|
-using System.ComponentModel;
|
|
|
-using System.Diagnostics;
|
|
|
using System.IO;
|
|
|
using System.Linq;
|
|
|
-using System.Reflection;
|
|
|
-using System.Runtime.InteropServices;
|
|
|
using System.Threading;
|
|
|
using System.Threading.Tasks;
|
|
|
|
|
|
@@ -22,7 +14,7 @@ namespace MediaBrowser.Controller.MediaInfo
|
|
|
/// <summary>
|
|
|
/// Class FFMpegManager
|
|
|
/// </summary>
|
|
|
- public class FFMpegManager : IDisposable
|
|
|
+ public class FFMpegManager
|
|
|
{
|
|
|
/// <summary>
|
|
|
/// Gets or sets the video image cache.
|
|
|
@@ -42,170 +34,35 @@ namespace MediaBrowser.Controller.MediaInfo
|
|
|
/// <value>The subtitle cache.</value>
|
|
|
internal FileSystemRepository SubtitleCache { get; set; }
|
|
|
|
|
|
- /// <summary>
|
|
|
- /// Gets or sets the zip client.
|
|
|
- /// </summary>
|
|
|
- /// <value>The zip client.</value>
|
|
|
- private readonly IZipClient _zipClient;
|
|
|
-
|
|
|
/// <summary>
|
|
|
/// The _logger
|
|
|
/// </summary>
|
|
|
private readonly Kernel _kernel;
|
|
|
|
|
|
- /// <summary>
|
|
|
- /// The _logger
|
|
|
- /// </summary>
|
|
|
- private readonly ILogger _logger;
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Gets the json serializer.
|
|
|
- /// </summary>
|
|
|
- /// <value>The json serializer.</value>
|
|
|
- private readonly IJsonSerializer _jsonSerializer;
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// The _protobuf serializer
|
|
|
- /// </summary>
|
|
|
- private readonly IProtobufSerializer _protobufSerializer;
|
|
|
private readonly IServerApplicationPaths _appPaths;
|
|
|
+ private readonly IMediaEncoder _encoder;
|
|
|
|
|
|
/// <summary>
|
|
|
/// Initializes a new instance of the <see cref="FFMpegManager" /> class.
|
|
|
/// </summary>
|
|
|
/// <param name="kernel">The kernel.</param>
|
|
|
- /// <param name="zipClient">The zip client.</param>
|
|
|
- /// <param name="jsonSerializer">The json serializer.</param>
|
|
|
- /// <param name="protobufSerializer">The protobuf serializer.</param>
|
|
|
- /// <param name="logger">The logger.</param>
|
|
|
+ /// <param name="appPaths">The app paths.</param>
|
|
|
+ /// <param name="encoder">The encoder.</param>
|
|
|
/// <exception cref="System.ArgumentNullException">zipClient</exception>
|
|
|
- public FFMpegManager(Kernel kernel, IZipClient zipClient, IJsonSerializer jsonSerializer, IProtobufSerializer protobufSerializer, ILogManager logManager, IServerApplicationPaths appPaths)
|
|
|
+ public FFMpegManager(Kernel kernel, IServerApplicationPaths appPaths, IMediaEncoder encoder)
|
|
|
{
|
|
|
if (kernel == null)
|
|
|
{
|
|
|
throw new ArgumentNullException("kernel");
|
|
|
}
|
|
|
- if (zipClient == null)
|
|
|
- {
|
|
|
- throw new ArgumentNullException("zipClient");
|
|
|
- }
|
|
|
- if (jsonSerializer == null)
|
|
|
- {
|
|
|
- throw new ArgumentNullException("jsonSerializer");
|
|
|
- }
|
|
|
- if (protobufSerializer == null)
|
|
|
- {
|
|
|
- throw new ArgumentNullException("protobufSerializer");
|
|
|
- }
|
|
|
|
|
|
_kernel = kernel;
|
|
|
- _zipClient = zipClient;
|
|
|
- _jsonSerializer = jsonSerializer;
|
|
|
- _protobufSerializer = protobufSerializer;
|
|
|
_appPaths = appPaths;
|
|
|
- _logger = logManager.GetLogger("FFMpegManager");
|
|
|
-
|
|
|
- // Not crazy about this but it's the only way to suppress ffmpeg crash dialog boxes
|
|
|
- SetErrorMode(ErrorModes.SEM_FAILCRITICALERRORS | ErrorModes.SEM_NOALIGNMENTFAULTEXCEPT | ErrorModes.SEM_NOGPFAULTERRORBOX | ErrorModes.SEM_NOOPENFILEERRORBOX);
|
|
|
+ _encoder = encoder;
|
|
|
|
|
|
VideoImageCache = new FileSystemRepository(VideoImagesDataPath);
|
|
|
AudioImageCache = new FileSystemRepository(AudioImagesDataPath);
|
|
|
SubtitleCache = new FileSystemRepository(SubtitleCachePath);
|
|
|
-
|
|
|
- Task.Run(() => VersionedDirectoryPath = GetVersionedDirectoryPath());
|
|
|
- }
|
|
|
-
|
|
|
- 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 void Dispose(bool dispose)
|
|
|
- {
|
|
|
- if (dispose)
|
|
|
- {
|
|
|
- SetErrorMode(ErrorModes.SYSTEM_DEFAULT);
|
|
|
-
|
|
|
- AudioImageCache.Dispose();
|
|
|
- VideoImageCache.Dispose();
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// The FF probe resource pool count
|
|
|
- /// </summary>
|
|
|
- private const int FFProbeResourcePoolCount = 3;
|
|
|
- /// <summary>
|
|
|
- /// The audio image resource pool count
|
|
|
- /// </summary>
|
|
|
- private const int AudioImageResourcePoolCount = 3;
|
|
|
- /// <summary>
|
|
|
- /// The video image resource pool count
|
|
|
- /// </summary>
|
|
|
- private const int VideoImageResourcePoolCount = 2;
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// The FF probe resource pool
|
|
|
- /// </summary>
|
|
|
- private readonly SemaphoreSlim FFProbeResourcePool = new SemaphoreSlim(FFProbeResourcePoolCount, FFProbeResourcePoolCount);
|
|
|
- /// <summary>
|
|
|
- /// The audio image resource pool
|
|
|
- /// </summary>
|
|
|
- private readonly SemaphoreSlim AudioImageResourcePool = new SemaphoreSlim(AudioImageResourcePoolCount, AudioImageResourcePoolCount);
|
|
|
- /// <summary>
|
|
|
- /// The video image resource pool
|
|
|
- /// </summary>
|
|
|
- private readonly SemaphoreSlim VideoImageResourcePool = new SemaphoreSlim(VideoImageResourcePoolCount, VideoImageResourcePoolCount);
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Gets or sets the versioned directory path.
|
|
|
- /// </summary>
|
|
|
- /// <value>The versioned directory path.</value>
|
|
|
- private string VersionedDirectoryPath { get; set; }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Gets the FFMPEG version.
|
|
|
- /// </summary>
|
|
|
- /// <value>The FFMPEG version.</value>
|
|
|
- public string FFMpegVersion
|
|
|
- {
|
|
|
- get { return Path.GetFileNameWithoutExtension(VersionedDirectoryPath); }
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// The _ FF MPEG path
|
|
|
- /// </summary>
|
|
|
- private string _FFMpegPath;
|
|
|
- /// <summary>
|
|
|
- /// Gets the path to ffmpeg.exe
|
|
|
- /// </summary>
|
|
|
- /// <value>The FF MPEG path.</value>
|
|
|
- public string FFMpegPath
|
|
|
- {
|
|
|
- get
|
|
|
- {
|
|
|
- return _FFMpegPath ?? (_FFMpegPath = Path.Combine(VersionedDirectoryPath, "ffmpeg.exe"));
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// The _ FF probe path
|
|
|
- /// </summary>
|
|
|
- private string _FFProbePath;
|
|
|
- /// <summary>
|
|
|
- /// Gets the path to ffprobe.exe
|
|
|
- /// </summary>
|
|
|
- /// <value>The FF probe path.</value>
|
|
|
- public string FFProbePath
|
|
|
- {
|
|
|
- get
|
|
|
- {
|
|
|
- return _FFProbePath ?? (_FFProbePath = Path.Combine(VersionedDirectoryPath, "ffprobe.exe"));
|
|
|
- }
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
@@ -222,7 +79,7 @@ namespace MediaBrowser.Controller.MediaInfo
|
|
|
{
|
|
|
if (_videoImagesDataPath == null)
|
|
|
{
|
|
|
- _videoImagesDataPath = Path.Combine(_appPaths.DataPath, "ffmpeg-video-images");
|
|
|
+ _videoImagesDataPath = Path.Combine(_appPaths.DataPath, "extracted-video-images");
|
|
|
|
|
|
if (!Directory.Exists(_videoImagesDataPath))
|
|
|
{
|
|
|
@@ -248,7 +105,7 @@ namespace MediaBrowser.Controller.MediaInfo
|
|
|
{
|
|
|
if (_audioImagesDataPath == null)
|
|
|
{
|
|
|
- _audioImagesDataPath = Path.Combine(_appPaths.DataPath, "ffmpeg-audio-images");
|
|
|
+ _audioImagesDataPath = Path.Combine(_appPaths.DataPath, "extracted-audio-images");
|
|
|
|
|
|
if (!Directory.Exists(_audioImagesDataPath))
|
|
|
{
|
|
|
@@ -274,7 +131,7 @@ namespace MediaBrowser.Controller.MediaInfo
|
|
|
{
|
|
|
if (_subtitleCachePath == null)
|
|
|
{
|
|
|
- _subtitleCachePath = Path.Combine(_appPaths.CachePath, "ffmpeg-subtitles");
|
|
|
+ _subtitleCachePath = Path.Combine(_appPaths.CachePath, "subtitles");
|
|
|
|
|
|
if (!Directory.Exists(_subtitleCachePath))
|
|
|
{
|
|
|
@@ -286,386 +143,10 @@ namespace MediaBrowser.Controller.MediaInfo
|
|
|
}
|
|
|
}
|
|
|
|
|
|
- /// <summary>
|
|
|
- /// The _media tools path
|
|
|
- /// </summary>
|
|
|
- private string _mediaToolsPath;
|
|
|
- /// <summary>
|
|
|
- /// Gets the folder path to tools
|
|
|
- /// </summary>
|
|
|
- /// <value>The media tools path.</value>
|
|
|
- private string MediaToolsPath
|
|
|
- {
|
|
|
- get
|
|
|
- {
|
|
|
- if (_mediaToolsPath == null)
|
|
|
- {
|
|
|
- _mediaToolsPath = Path.Combine(_appPaths.ProgramDataPath, "ffmpeg");
|
|
|
-
|
|
|
- if (!Directory.Exists(_mediaToolsPath))
|
|
|
- {
|
|
|
- Directory.CreateDirectory(_mediaToolsPath);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return _mediaToolsPath;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Gets the versioned directory path.
|
|
|
- /// </summary>
|
|
|
- /// <returns>System.String.</returns>
|
|
|
- private string GetVersionedDirectoryPath()
|
|
|
- {
|
|
|
- var assembly = GetType().Assembly;
|
|
|
-
|
|
|
- const string prefix = "MediaBrowser.Controller.MediaInfo.";
|
|
|
- const string srch = prefix + "ffmpeg";
|
|
|
-
|
|
|
- var resource = assembly.GetManifestResourceNames().First(r => r.StartsWith(srch));
|
|
|
-
|
|
|
- var filename = resource.Substring(resource.IndexOf(prefix, StringComparison.OrdinalIgnoreCase) + prefix.Length);
|
|
|
-
|
|
|
- var versionedDirectoryPath = Path.Combine(MediaToolsPath, Path.GetFileNameWithoutExtension(filename));
|
|
|
-
|
|
|
- if (!Directory.Exists(versionedDirectoryPath))
|
|
|
- {
|
|
|
- Directory.CreateDirectory(versionedDirectoryPath);
|
|
|
- }
|
|
|
-
|
|
|
- ExtractTools(assembly, resource, versionedDirectoryPath);
|
|
|
-
|
|
|
- return versionedDirectoryPath;
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Extracts the tools.
|
|
|
- /// </summary>
|
|
|
- /// <param name="assembly">The assembly.</param>
|
|
|
- /// <param name="zipFileResourcePath">The zip file resource path.</param>
|
|
|
- /// <param name="targetPath">The target path.</param>
|
|
|
- private void ExtractTools(Assembly assembly, string zipFileResourcePath, string targetPath)
|
|
|
- {
|
|
|
- using (var resourceStream = assembly.GetManifestResourceStream(zipFileResourcePath))
|
|
|
- {
|
|
|
- _zipClient.ExtractAll(resourceStream, targetPath, false);
|
|
|
- }
|
|
|
-
|
|
|
- ExtractFonts(assembly, targetPath);
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Extracts the fonts.
|
|
|
- /// </summary>
|
|
|
- /// <param name="assembly">The assembly.</param>
|
|
|
- /// <param name="targetPath">The target path.</param>
|
|
|
- private async void ExtractFonts(Assembly assembly, string targetPath)
|
|
|
- {
|
|
|
- var fontsDirectory = Path.Combine(targetPath, "fonts");
|
|
|
-
|
|
|
- if (!Directory.Exists(fontsDirectory))
|
|
|
- {
|
|
|
- Directory.CreateDirectory(fontsDirectory);
|
|
|
- }
|
|
|
-
|
|
|
- const string fontFilename = "ARIALUNI.TTF";
|
|
|
-
|
|
|
- var fontFile = Path.Combine(fontsDirectory, fontFilename);
|
|
|
-
|
|
|
- if (!File.Exists(fontFile))
|
|
|
- {
|
|
|
- using (var stream = assembly.GetManifestResourceStream("MediaBrowser.Controller.MediaInfo.fonts." + fontFilename))
|
|
|
- {
|
|
|
- using (var fileStream = new FileStream(fontFile, FileMode.Create, FileAccess.Write, FileShare.Read, StreamDefaults.DefaultFileStreamBufferSize, FileOptions.Asynchronous))
|
|
|
- {
|
|
|
- await stream.CopyToAsync(fileStream).ConfigureAwait(false);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- await ExtractFontConfigFile(assembly, fontsDirectory).ConfigureAwait(false);
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Extracts the font config file.
|
|
|
- /// </summary>
|
|
|
- /// <param name="assembly">The assembly.</param>
|
|
|
- /// <param name="fontsDirectory">The fonts directory.</param>
|
|
|
- private async Task ExtractFontConfigFile(Assembly assembly, string fontsDirectory)
|
|
|
- {
|
|
|
- const string fontConfigFilename = "fonts.conf";
|
|
|
- var fontConfigFile = Path.Combine(fontsDirectory, fontConfigFilename);
|
|
|
-
|
|
|
- if (!File.Exists(fontConfigFile))
|
|
|
- {
|
|
|
- using (var stream = assembly.GetManifestResourceStream("MediaBrowser.Controller.MediaInfo.fonts." + fontConfigFilename))
|
|
|
- {
|
|
|
- using (var streamReader = new StreamReader(stream))
|
|
|
- {
|
|
|
- var contents = await streamReader.ReadToEndAsync().ConfigureAwait(false);
|
|
|
-
|
|
|
- contents = contents.Replace("<dir></dir>", "<dir>" + fontsDirectory + "</dir>");
|
|
|
-
|
|
|
- var bytes = Encoding.UTF8.GetBytes(contents);
|
|
|
-
|
|
|
- using (var fileStream = new FileStream(fontConfigFile, FileMode.Create, FileAccess.Write, FileShare.Read, StreamDefaults.DefaultFileStreamBufferSize, FileOptions.Asynchronous))
|
|
|
- {
|
|
|
- await fileStream.WriteAsync(bytes, 0, bytes.Length);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Gets the probe size argument.
|
|
|
- /// </summary>
|
|
|
- /// <param name="item">The item.</param>
|
|
|
- /// <returns>System.String.</returns>
|
|
|
- public string GetProbeSizeArgument(BaseItem item)
|
|
|
- {
|
|
|
- var video = item as Video;
|
|
|
-
|
|
|
- return video != null ? GetProbeSizeArgument(video.VideoType, video.IsoType) : string.Empty;
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Gets the probe size argument.
|
|
|
- /// </summary>
|
|
|
- /// <param name="videoType">Type of the video.</param>
|
|
|
- /// <param name="isoType">Type of the iso.</param>
|
|
|
- /// <returns>System.String.</returns>
|
|
|
- public string GetProbeSizeArgument(VideoType videoType, IsoType? isoType)
|
|
|
- {
|
|
|
- if (videoType == VideoType.Dvd || (isoType.HasValue && isoType.Value == IsoType.Dvd))
|
|
|
- {
|
|
|
- return "-probesize 1G -analyzeduration 200M";
|
|
|
- }
|
|
|
-
|
|
|
- return string.Empty;
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Runs FFProbe against a BaseItem
|
|
|
- /// </summary>
|
|
|
- /// <param name="item">The item.</param>
|
|
|
- /// <param name="inputPath">The input path.</param>
|
|
|
- /// <param name="lastDateModified">The last date modified.</param>
|
|
|
- /// <param name="cache">The cache.</param>
|
|
|
- /// <param name="cancellationToken">The cancellation token.</param>
|
|
|
- /// <returns>Task{FFProbeResult}.</returns>
|
|
|
- /// <exception cref="System.ArgumentNullException">item</exception>
|
|
|
- public Task<FFProbeResult> RunFFProbe(BaseItem item, string inputPath, DateTime lastDateModified, FileSystemRepository cache, CancellationToken cancellationToken)
|
|
|
- {
|
|
|
- if (string.IsNullOrEmpty(inputPath))
|
|
|
- {
|
|
|
- throw new ArgumentNullException("inputPath");
|
|
|
- }
|
|
|
-
|
|
|
- if (cache == null)
|
|
|
- {
|
|
|
- throw new ArgumentNullException("cache");
|
|
|
- }
|
|
|
-
|
|
|
- // Put the ffmpeg version into the cache name so that it's unique per-version
|
|
|
- // We don't want to try and deserialize data based on an old version, which could potentially fail
|
|
|
- var resourceName = item.Id + "_" + lastDateModified.Ticks + "_" + FFMpegVersion;
|
|
|
-
|
|
|
- // Forumulate the cache file path
|
|
|
- var cacheFilePath = cache.GetResourcePath(resourceName, ".pb");
|
|
|
-
|
|
|
- cancellationToken.ThrowIfCancellationRequested();
|
|
|
-
|
|
|
- // Avoid File.Exists by just trying to deserialize
|
|
|
- try
|
|
|
- {
|
|
|
- return Task.FromResult(_protobufSerializer.DeserializeFromFile<FFProbeResult>(cacheFilePath));
|
|
|
- }
|
|
|
- catch (FileNotFoundException)
|
|
|
- {
|
|
|
- var extractChapters = false;
|
|
|
- var video = item as Video;
|
|
|
- var probeSizeArgument = string.Empty;
|
|
|
-
|
|
|
- if (video != null)
|
|
|
- {
|
|
|
- extractChapters = true;
|
|
|
- probeSizeArgument = GetProbeSizeArgument(video.VideoType, video.IsoType);
|
|
|
- }
|
|
|
-
|
|
|
- return RunFFProbeInternal(inputPath, extractChapters, cacheFilePath, probeSizeArgument, cancellationToken);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Runs FFProbe against a BaseItem
|
|
|
- /// </summary>
|
|
|
- /// <param name="inputPath">The input path.</param>
|
|
|
- /// <param name="extractChapters">if set to <c>true</c> [extract chapters].</param>
|
|
|
- /// <param name="cacheFile">The cache file.</param>
|
|
|
- /// <param name="probeSizeArgument">The probe size argument.</param>
|
|
|
- /// <param name="cancellationToken">The cancellation token.</param>
|
|
|
- /// <returns>Task{FFProbeResult}.</returns>
|
|
|
- /// <exception cref="System.ApplicationException"></exception>
|
|
|
- private async Task<FFProbeResult> RunFFProbeInternal(string inputPath, bool extractChapters, string cacheFile, string probeSizeArgument, CancellationToken cancellationToken)
|
|
|
- {
|
|
|
- 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("{0} -i {1} -threads 0 -v info -print_format json -show_streams -show_format", 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);
|
|
|
-
|
|
|
- FFProbeResult result;
|
|
|
- string standardError = null;
|
|
|
-
|
|
|
- try
|
|
|
- {
|
|
|
- process.Start();
|
|
|
-
|
|
|
- Task<string> standardErrorReadTask = null;
|
|
|
-
|
|
|
- // MUST read both stdout and stderr asynchronously or a deadlock may occurr
|
|
|
- if (extractChapters)
|
|
|
- {
|
|
|
- standardErrorReadTask = process.StandardError.ReadToEndAsync();
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- process.BeginErrorReadLine();
|
|
|
- }
|
|
|
-
|
|
|
- result = _jsonSerializer.DeserializeFromStream<FFProbeResult>(process.StandardOutput.BaseStream);
|
|
|
-
|
|
|
- if (extractChapters)
|
|
|
- {
|
|
|
- standardError = await standardErrorReadTask.ConfigureAwait(false);
|
|
|
- }
|
|
|
- }
|
|
|
- catch
|
|
|
- {
|
|
|
- // Hate having to do this
|
|
|
- try
|
|
|
- {
|
|
|
- process.Kill();
|
|
|
- }
|
|
|
- catch (InvalidOperationException ex1)
|
|
|
- {
|
|
|
- _logger.ErrorException("Error killing ffprobe", ex1);
|
|
|
- }
|
|
|
- catch (Win32Exception 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 (extractChapters && !string.IsNullOrEmpty(standardError))
|
|
|
- {
|
|
|
- AddChapters(result, standardError);
|
|
|
- }
|
|
|
-
|
|
|
- _protobufSerializer.SerializeToFile(result, cacheFile);
|
|
|
-
|
|
|
- return result;
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Adds the chapters.
|
|
|
- /// </summary>
|
|
|
- /// <param name="result">The result.</param>
|
|
|
- /// <param name="standardError">The standard error.</param>
|
|
|
- private void AddChapters(FFProbeResult result, string standardError)
|
|
|
- {
|
|
|
- var lines = standardError.Split('\n').Select(l => l.TrimStart());
|
|
|
-
|
|
|
- var chapters = new List<ChapterInfo> { };
|
|
|
-
|
|
|
- ChapterInfo lastChapter = null;
|
|
|
-
|
|
|
- foreach (var line in lines)
|
|
|
- {
|
|
|
- if (line.StartsWith("Chapter", StringComparison.OrdinalIgnoreCase))
|
|
|
- {
|
|
|
- // Example:
|
|
|
- // Chapter #0.2: start 400.534, end 4565.435
|
|
|
- const string srch = "start ";
|
|
|
- var start = line.IndexOf(srch, StringComparison.OrdinalIgnoreCase);
|
|
|
-
|
|
|
- if (start == -1)
|
|
|
- {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- var subString = line.Substring(start + srch.Length);
|
|
|
- subString = subString.Substring(0, subString.IndexOf(','));
|
|
|
-
|
|
|
- double seconds;
|
|
|
-
|
|
|
- if (double.TryParse(subString, out seconds))
|
|
|
- {
|
|
|
- lastChapter = new ChapterInfo
|
|
|
- {
|
|
|
- StartPositionTicks = TimeSpan.FromSeconds(seconds).Ticks
|
|
|
- };
|
|
|
-
|
|
|
- chapters.Add(lastChapter);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- else if (line.StartsWith("title", StringComparison.OrdinalIgnoreCase))
|
|
|
- {
|
|
|
- if (lastChapter != null && string.IsNullOrEmpty(lastChapter.Name))
|
|
|
- {
|
|
|
- var index = line.IndexOf(':');
|
|
|
-
|
|
|
- if (index != -1)
|
|
|
- {
|
|
|
- lastChapter.Name = line.Substring(index + 1).Trim().TrimEnd('\r');
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- result.Chapters = chapters;
|
|
|
- }
|
|
|
-
|
|
|
/// <summary>
|
|
|
/// The first chapter ticks
|
|
|
/// </summary>
|
|
|
- private static long FirstChapterTicks = TimeSpan.FromSeconds(15).Ticks;
|
|
|
+ private static readonly long FirstChapterTicks = TimeSpan.FromSeconds(15).Ticks;
|
|
|
|
|
|
/// <summary>
|
|
|
/// Extracts the chapter images.
|
|
|
@@ -710,14 +191,17 @@ namespace MediaBrowser.Controller.MediaInfo
|
|
|
// Add some time for the first chapter to make sure we don't end up with a black image
|
|
|
var time = chapter.StartPositionTicks == 0 ? TimeSpan.FromTicks(Math.Min(FirstChapterTicks, video.RunTimeTicks ?? 0)) : TimeSpan.FromTicks(chapter.StartPositionTicks);
|
|
|
|
|
|
- var success = await ExtractImage(GetInputArgument(video), time, path, cancellationToken).ConfigureAwait(false);
|
|
|
+ InputType type;
|
|
|
|
|
|
- if (success)
|
|
|
+ var inputPath = MediaEncoderHelpers.GetInputArgument(video, null, out type);
|
|
|
+
|
|
|
+ try
|
|
|
{
|
|
|
+ await _encoder.ExtractImage(inputPath, type, time, path, cancellationToken).ConfigureAwait(false);
|
|
|
chapter.ImagePath = path;
|
|
|
changesMade = true;
|
|
|
}
|
|
|
- else
|
|
|
+ catch
|
|
|
{
|
|
|
break;
|
|
|
}
|
|
|
@@ -736,70 +220,6 @@ namespace MediaBrowser.Controller.MediaInfo
|
|
|
}
|
|
|
}
|
|
|
|
|
|
- /// <summary>
|
|
|
- /// Extracts an image from an Audio file and returns a Task whose result indicates whether it was successful or not
|
|
|
- /// </summary>
|
|
|
- /// <param name="inputPath">The input path.</param>
|
|
|
- /// <param name="outputPath">The output path.</param>
|
|
|
- /// <param name="cancellationToken">The cancellation token.</param>
|
|
|
- /// <returns>Task{System.Boolean}.</returns>
|
|
|
- /// <exception cref="System.ArgumentNullException">input</exception>
|
|
|
- public async Task<bool> ExtractAudioImage(string inputPath, string outputPath, CancellationToken cancellationToken)
|
|
|
- {
|
|
|
- if (string.IsNullOrEmpty(inputPath))
|
|
|
- {
|
|
|
- throw new ArgumentNullException("inputPath");
|
|
|
- }
|
|
|
-
|
|
|
- if (string.IsNullOrEmpty(outputPath))
|
|
|
- {
|
|
|
- throw new ArgumentNullException("outputPath");
|
|
|
- }
|
|
|
-
|
|
|
- var process = new Process
|
|
|
- {
|
|
|
- StartInfo = new ProcessStartInfo
|
|
|
- {
|
|
|
- CreateNoWindow = true,
|
|
|
- UseShellExecute = false,
|
|
|
- FileName = FFMpegPath,
|
|
|
- Arguments = string.Format("-i {0} -threads 0 -v quiet -f image2 \"{1}\"", GetFileInputArgument(inputPath), outputPath),
|
|
|
- WindowStyle = ProcessWindowStyle.Hidden,
|
|
|
- ErrorDialog = false
|
|
|
- }
|
|
|
- };
|
|
|
-
|
|
|
- await AudioImageResourcePool.WaitAsync(cancellationToken).ConfigureAwait(false);
|
|
|
-
|
|
|
- await RunAsync(process).ConfigureAwait(false);
|
|
|
-
|
|
|
- AudioImageResourcePool.Release();
|
|
|
-
|
|
|
- var exitCode = process.ExitCode;
|
|
|
-
|
|
|
- process.Dispose();
|
|
|
-
|
|
|
- if (exitCode != -1 && File.Exists(outputPath))
|
|
|
- {
|
|
|
- return true;
|
|
|
- }
|
|
|
-
|
|
|
- _logger.Error("ffmpeg audio image extraction failed for {0}", inputPath);
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Determines whether [is subtitle cached] [the specified input].
|
|
|
- /// </summary>
|
|
|
- /// <param name="input">The input.</param>
|
|
|
- /// <param name="subtitleStreamIndex">Index of the subtitle stream.</param>
|
|
|
- /// <param name="outputExtension">The output extension.</param>
|
|
|
- /// <returns><c>true</c> if [is subtitle cached] [the specified input]; otherwise, <c>false</c>.</returns>
|
|
|
- public bool IsSubtitleCached(Video input, int subtitleStreamIndex, string outputExtension)
|
|
|
- {
|
|
|
- return SubtitleCache.ContainsFilePath(GetSubtitleCachePath(input, subtitleStreamIndex, outputExtension));
|
|
|
- }
|
|
|
-
|
|
|
/// <summary>
|
|
|
/// Gets the subtitle cache path.
|
|
|
/// </summary>
|
|
|
@@ -811,364 +231,5 @@ namespace MediaBrowser.Controller.MediaInfo
|
|
|
{
|
|
|
return SubtitleCache.GetResourcePath(input.Id + "_" + subtitleStreamIndex + "_" + input.DateModified.Ticks, outputExtension);
|
|
|
}
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Extracts the text subtitle.
|
|
|
- /// </summary>
|
|
|
- /// <param name="input">The input.</param>
|
|
|
- /// <param name="subtitleStreamIndex">Index of the subtitle stream.</param>
|
|
|
- /// <param name="outputPath">The output path.</param>
|
|
|
- /// <param name="cancellationToken">The cancellation token.</param>
|
|
|
- /// <returns>Task{System.Boolean}.</returns>
|
|
|
- /// <exception cref="System.ArgumentNullException">input</exception>
|
|
|
- public async Task<bool> ExtractTextSubtitle(Video input, int subtitleStreamIndex, string outputPath, CancellationToken cancellationToken)
|
|
|
- {
|
|
|
- if (input == null)
|
|
|
- {
|
|
|
- throw new ArgumentNullException("input");
|
|
|
- }
|
|
|
-
|
|
|
- if (cancellationToken == null)
|
|
|
- {
|
|
|
- throw new ArgumentNullException("cancellationToken");
|
|
|
- }
|
|
|
-
|
|
|
- var process = new Process
|
|
|
- {
|
|
|
- StartInfo = new ProcessStartInfo
|
|
|
- {
|
|
|
- CreateNoWindow = true,
|
|
|
- UseShellExecute = false,
|
|
|
- FileName = FFMpegPath,
|
|
|
- Arguments = string.Format("-i {0} -map 0:{1} -an -vn -c:s ass \"{2}\"", GetInputArgument(input), subtitleStreamIndex, outputPath),
|
|
|
- WindowStyle = ProcessWindowStyle.Hidden,
|
|
|
- ErrorDialog = false
|
|
|
- }
|
|
|
- };
|
|
|
-
|
|
|
- _logger.Debug("{0} {1}", process.StartInfo.FileName, process.StartInfo.Arguments);
|
|
|
-
|
|
|
- await AudioImageResourcePool.WaitAsync(cancellationToken).ConfigureAwait(false);
|
|
|
-
|
|
|
- await RunAsync(process).ConfigureAwait(false);
|
|
|
-
|
|
|
- AudioImageResourcePool.Release();
|
|
|
-
|
|
|
- var exitCode = process.ExitCode;
|
|
|
-
|
|
|
- process.Dispose();
|
|
|
-
|
|
|
- if (exitCode != -1 && File.Exists(outputPath))
|
|
|
- {
|
|
|
- return true;
|
|
|
- }
|
|
|
-
|
|
|
- _logger.Error("ffmpeg subtitle extraction failed for {0}", input.Path);
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Converts the text subtitle.
|
|
|
- /// </summary>
|
|
|
- /// <param name="mediaStream">The media stream.</param>
|
|
|
- /// <param name="outputPath">The output path.</param>
|
|
|
- /// <param name="cancellationToken">The cancellation token.</param>
|
|
|
- /// <returns>Task{System.Boolean}.</returns>
|
|
|
- /// <exception cref="System.ArgumentNullException">mediaStream</exception>
|
|
|
- /// <exception cref="System.ArgumentException">The given MediaStream is not an external subtitle stream</exception>
|
|
|
- public async Task<bool> ConvertTextSubtitle(MediaStream mediaStream, string outputPath, CancellationToken cancellationToken)
|
|
|
- {
|
|
|
- if (mediaStream == null)
|
|
|
- {
|
|
|
- throw new ArgumentNullException("mediaStream");
|
|
|
- }
|
|
|
-
|
|
|
- if (!mediaStream.IsExternal || string.IsNullOrEmpty(mediaStream.Path))
|
|
|
- {
|
|
|
- throw new ArgumentException("The given MediaStream is not an external subtitle stream");
|
|
|
- }
|
|
|
-
|
|
|
- var process = new Process
|
|
|
- {
|
|
|
- StartInfo = new ProcessStartInfo
|
|
|
- {
|
|
|
- CreateNoWindow = true,
|
|
|
- UseShellExecute = false,
|
|
|
- FileName = FFMpegPath,
|
|
|
- Arguments = string.Format("-i \"{0}\" \"{1}\"", mediaStream.Path, outputPath),
|
|
|
- WindowStyle = ProcessWindowStyle.Hidden,
|
|
|
- ErrorDialog = false
|
|
|
- }
|
|
|
- };
|
|
|
-
|
|
|
- _logger.Debug("{0} {1}", process.StartInfo.FileName, process.StartInfo.Arguments);
|
|
|
-
|
|
|
- await AudioImageResourcePool.WaitAsync(cancellationToken).ConfigureAwait(false);
|
|
|
-
|
|
|
- await RunAsync(process).ConfigureAwait(false);
|
|
|
-
|
|
|
- AudioImageResourcePool.Release();
|
|
|
-
|
|
|
- var exitCode = process.ExitCode;
|
|
|
-
|
|
|
- process.Dispose();
|
|
|
-
|
|
|
- if (exitCode != -1 && File.Exists(outputPath))
|
|
|
- {
|
|
|
- return true;
|
|
|
- }
|
|
|
-
|
|
|
- _logger.Error("ffmpeg subtitle conversion failed for {0}", mediaStream.Path);
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Extracts an image from a Video and returns a Task whose result indicates whether it was successful or not
|
|
|
- /// </summary>
|
|
|
- /// <param name="inputPath">The input path.</param>
|
|
|
- /// <param name="offset">The offset.</param>
|
|
|
- /// <param name="outputPath">The output path.</param>
|
|
|
- /// <param name="cancellationToken">The cancellation token.</param>
|
|
|
- /// <returns>Task{System.Boolean}.</returns>
|
|
|
- /// <exception cref="System.ArgumentNullException">video</exception>
|
|
|
- public async Task<bool> ExtractImage(string inputPath, TimeSpan offset, string outputPath, CancellationToken cancellationToken)
|
|
|
- {
|
|
|
- if (string.IsNullOrEmpty(inputPath))
|
|
|
- {
|
|
|
- throw new ArgumentNullException("inputPath");
|
|
|
- }
|
|
|
-
|
|
|
- if (string.IsNullOrEmpty(outputPath))
|
|
|
- {
|
|
|
- throw new ArgumentNullException("outputPath");
|
|
|
- }
|
|
|
-
|
|
|
- var process = new Process
|
|
|
- {
|
|
|
- StartInfo = new ProcessStartInfo
|
|
|
- {
|
|
|
- CreateNoWindow = true,
|
|
|
- UseShellExecute = false,
|
|
|
- FileName = FFMpegPath,
|
|
|
- Arguments = string.Format("-ss {0} -i {1} -threads 0 -v quiet -vframes 1 -filter:v select=\\'eq(pict_type\\,I)\\' -f image2 \"{2}\"", Convert.ToInt32(offset.TotalSeconds), inputPath, outputPath),
|
|
|
- WindowStyle = ProcessWindowStyle.Hidden,
|
|
|
- ErrorDialog = false
|
|
|
- }
|
|
|
- };
|
|
|
-
|
|
|
- await VideoImageResourcePool.WaitAsync(cancellationToken).ConfigureAwait(false);
|
|
|
-
|
|
|
- process.Start();
|
|
|
-
|
|
|
- var ranToCompletion = process.WaitForExit(10000);
|
|
|
-
|
|
|
- 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);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- VideoImageResourcePool.Release();
|
|
|
-
|
|
|
- var exitCode = ranToCompletion ? process.ExitCode : -1;
|
|
|
-
|
|
|
- process.Dispose();
|
|
|
-
|
|
|
- if (exitCode == -1)
|
|
|
- {
|
|
|
- if (File.Exists(outputPath))
|
|
|
- {
|
|
|
- try
|
|
|
- {
|
|
|
- _logger.Info("Deleting extracted image due to failure: ", outputPath);
|
|
|
- File.Delete(outputPath);
|
|
|
- }
|
|
|
- catch (IOException ex)
|
|
|
- {
|
|
|
- _logger.ErrorException("Error deleting extracted image {0}", ex, outputPath);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- if (File.Exists(outputPath))
|
|
|
- {
|
|
|
- return true;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- _logger.Error("ffmpeg video image extraction failed for {0}", inputPath);
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Gets the input argument.
|
|
|
- /// </summary>
|
|
|
- /// <param name="item">The item.</param>
|
|
|
- /// <returns>System.String.</returns>
|
|
|
- public string GetInputArgument(BaseItem item)
|
|
|
- {
|
|
|
- var video = item as Video;
|
|
|
-
|
|
|
- if (video != null)
|
|
|
- {
|
|
|
- if (video.VideoType == VideoType.BluRay)
|
|
|
- {
|
|
|
- return GetBlurayInputArgument(video.Path);
|
|
|
- }
|
|
|
-
|
|
|
- if (video.VideoType == VideoType.Dvd)
|
|
|
- {
|
|
|
- return GetDvdInputArgument(video.GetPlayableStreamFiles());
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return string.Format("file:\"{0}\"", item.Path);
|
|
|
- }
|
|
|
-
|
|
|
- /// <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 input argument.
|
|
|
- /// </summary>
|
|
|
- /// <param name="item">The item.</param>
|
|
|
- /// <param name="mount">The mount.</param>
|
|
|
- /// <returns>System.String.</returns>
|
|
|
- public string GetInputArgument(Video item, IIsoMount mount)
|
|
|
- {
|
|
|
- if (item.VideoType == VideoType.Iso && item.IsoType.HasValue)
|
|
|
- {
|
|
|
- if (item.IsoType.Value == IsoType.BluRay)
|
|
|
- {
|
|
|
- return GetBlurayInputArgument(mount.MountedPath);
|
|
|
- }
|
|
|
- if (item.IsoType.Value == IsoType.Dvd)
|
|
|
- {
|
|
|
- return GetDvdInputArgument(item.GetPlayableStreamFiles(mount.MountedPath));
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return GetInputArgument(item);
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Gets the bluray input argument.
|
|
|
- /// </summary>
|
|
|
- /// <param name="blurayRoot">The bluray root.</param>
|
|
|
- /// <returns>System.String.</returns>
|
|
|
- public string GetBlurayInputArgument(string blurayRoot)
|
|
|
- {
|
|
|
- return string.Format("bluray:\"{0}\"", blurayRoot);
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Gets the DVD input argument.
|
|
|
- /// </summary>
|
|
|
- /// <param name="playableStreamFiles">The playable stream files.</param>
|
|
|
- /// <returns>System.String.</returns>
|
|
|
- public string GetDvdInputArgument(IEnumerable<string> playableStreamFiles)
|
|
|
- {
|
|
|
- // Get all streams
|
|
|
- var streamFilePaths = (playableStreamFiles ?? new string[] { }).ToArray();
|
|
|
-
|
|
|
- // If there's more than one we'll need to use the concat command
|
|
|
- if (streamFilePaths.Length > 1)
|
|
|
- {
|
|
|
- var files = string.Join("|", streamFilePaths);
|
|
|
-
|
|
|
- return string.Format("concat:\"{0}\"", files);
|
|
|
- }
|
|
|
-
|
|
|
- // Determine the input path for video files
|
|
|
- return string.Format("file:\"{0}\"", streamFilePaths[0]);
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Processes the exited.
|
|
|
- /// </summary>
|
|
|
- /// <param name="sender">The sender.</param>
|
|
|
- /// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
|
|
|
- void ProcessExited(object sender, EventArgs e)
|
|
|
- {
|
|
|
- ((Process)sender).Dispose();
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Provides a non-blocking method to start a process and wait asynchronously for it to exit
|
|
|
- /// </summary>
|
|
|
- /// <param name="process">The process.</param>
|
|
|
- /// <returns>Task{System.Boolean}.</returns>
|
|
|
- private static Task<bool> RunAsync(Process process)
|
|
|
- {
|
|
|
- var tcs = new TaskCompletionSource<bool>();
|
|
|
-
|
|
|
- process.EnableRaisingEvents = true;
|
|
|
- process.Exited += (sender, args) => tcs.SetResult(true);
|
|
|
-
|
|
|
- process.Start();
|
|
|
-
|
|
|
- return tcs.Task;
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Sets the error mode.
|
|
|
- /// </summary>
|
|
|
- /// <param name="uMode">The u mode.</param>
|
|
|
- /// <returns>ErrorModes.</returns>
|
|
|
- [DllImport("kernel32.dll")]
|
|
|
- static extern ErrorModes SetErrorMode(ErrorModes uMode);
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Enum ErrorModes
|
|
|
- /// </summary>
|
|
|
- [Flags]
|
|
|
- public enum ErrorModes : uint
|
|
|
- {
|
|
|
- /// <summary>
|
|
|
- /// The SYSTE m_ DEFAULT
|
|
|
- /// </summary>
|
|
|
- SYSTEM_DEFAULT = 0x0,
|
|
|
- /// <summary>
|
|
|
- /// The SE m_ FAILCRITICALERRORS
|
|
|
- /// </summary>
|
|
|
- SEM_FAILCRITICALERRORS = 0x0001,
|
|
|
- /// <summary>
|
|
|
- /// The SE m_ NOALIGNMENTFAULTEXCEPT
|
|
|
- /// </summary>
|
|
|
- SEM_NOALIGNMENTFAULTEXCEPT = 0x0004,
|
|
|
- /// <summary>
|
|
|
- /// The SE m_ NOGPFAULTERRORBOX
|
|
|
- /// </summary>
|
|
|
- SEM_NOGPFAULTERRORBOX = 0x0002,
|
|
|
- /// <summary>
|
|
|
- /// The SE m_ NOOPENFILEERRORBOX
|
|
|
- /// </summary>
|
|
|
- SEM_NOOPENFILEERRORBOX = 0x8000
|
|
|
- }
|
|
|
}
|
|
|
}
|
Luke Pulverenti