public ImageProcessor(ILogger logger, IServerApplicationPaths appPaths, IFileSystem fileSystem, IJsonSerializer jsonSerializer, IMediaEncoder mediaEncoder)
        {
            _logger = logger;
            _fileSystem = fileSystem;
            _jsonSerializer = jsonSerializer;
            _mediaEncoder = mediaEncoder;
            _appPaths = appPaths;

            _saveImageSizeTimer = new Timer(SaveImageSizeCallback, null, Timeout.Infinite, Timeout.Infinite);

            Dictionary<Guid, ImageSize> sizeDictionary;

            try
            {
                sizeDictionary = jsonSerializer.DeserializeFromFile<Dictionary<Guid, ImageSize>>(ImageSizeFile) ??
                    new Dictionary<Guid, ImageSize>();
            }
            catch (FileNotFoundException)
            {
                // No biggie
                sizeDictionary = new Dictionary<Guid, ImageSize>();
            }
            catch (Exception ex)
            {
                logger.ErrorException("Error parsing image size cache file", ex);

                sizeDictionary = new Dictionary<Guid, ImageSize>();
            }

            _cachedImagedSizes = new ConcurrentDictionary<Guid, ImageSize>(sizeDictionary);
        }

 public AudioImageProvider(IIsoManager isoManager, IMediaEncoder mediaEncoder, IServerConfigurationManager config, IFileSystem fileSystem)
 {
     _isoManager = isoManager;
     _mediaEncoder = mediaEncoder;
     _config = config;
     _fileSystem = fileSystem;
 }

 protected BaseTunerHost(IConfigurationManager config, ILogger logger, IJsonSerializer jsonSerializer, IMediaEncoder mediaEncoder)
 {
     Config = config;
     Logger = logger;
     JsonSerializer = jsonSerializer;
     MediaEncoder = mediaEncoder;
 }

 public BifService(IServerApplicationPaths appPaths, ILibraryManager libraryManager, IMediaEncoder mediaEncoder, IFileSystem fileSystem)
 {
     _appPaths = appPaths;
     _libraryManager = libraryManager;
     _mediaEncoder = mediaEncoder;
     _fileSystem = fileSystem;
 }

 public DlnaEntryPoint(IServerConfigurationManager config,
     ILogManager logManager,
     IServerApplicationHost appHost,
     INetworkManager network,
     ISessionManager sessionManager,
     IHttpClient httpClient,
     ILibraryManager libraryManager,
     IUserManager userManager,
     IDlnaManager dlnaManager,
     IImageProcessor imageProcessor,
     IUserDataManager userDataManager,
     ILocalizationManager localization,
     IMediaSourceManager mediaSourceManager,
     ISsdpHandler ssdpHandler, IDeviceDiscovery deviceDiscovery, IMediaEncoder mediaEncoder)
 {
     _config = config;
     _appHost = appHost;
     _network = network;
     _sessionManager = sessionManager;
     _httpClient = httpClient;
     _libraryManager = libraryManager;
     _userManager = userManager;
     _dlnaManager = dlnaManager;
     _imageProcessor = imageProcessor;
     _userDataManager = userDataManager;
     _localization = localization;
     _mediaSourceManager = mediaSourceManager;
     _deviceDiscovery = deviceDiscovery;
     _mediaEncoder = mediaEncoder;
     _ssdpHandler = (SsdpHandler)ssdpHandler;
     _logger = logManager.GetLogger("Dlna");
 }

 public SatIpHost(IServerConfigurationManager config, ILogger logger, IJsonSerializer jsonSerializer, IMediaEncoder mediaEncoder, IFileSystem fileSystem, IHttpClient httpClient, IServerApplicationHost appHost)
     : base(config, logger, jsonSerializer, mediaEncoder)
 {
     _fileSystem = fileSystem;
     _httpClient = httpClient;
     _appHost = appHost;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="BaseMetadataProvider" /> class.
        /// </summary>
        /// <param name="logManager">The log manager.</param>
        /// <param name="configurationManager">The configuration manager.</param>
        /// <param name="mediaEncoder">The media encoder.</param>
        public AudioImageProvider(ILogManager logManager, IServerConfigurationManager configurationManager, IMediaEncoder mediaEncoder)
            : base(logManager, configurationManager)
        {
            _mediaEncoder = mediaEncoder;

            ImageCache = new FileSystemRepository(Kernel.Instance.FFMpegManager.AudioImagesDataPath);
        }

 public SubtitleEncoder(ILibraryManager libraryManager, ILogger logger, IApplicationPaths appPaths, IFileSystem fileSystem, IMediaEncoder mediaEncoder)
 {
     _libraryManager = libraryManager;
     _logger = logger;
     _appPaths = appPaths;
     _fileSystem = fileSystem;
     _mediaEncoder = mediaEncoder;
 }

 public EncodedRecorder(ILogger logger, IFileSystem fileSystem, IMediaEncoder mediaEncoder, IApplicationPaths appPaths, IJsonSerializer json)
 {
     _logger = logger;
     _fileSystem = fileSystem;
     _mediaEncoder = mediaEncoder;
     _appPaths = appPaths;
     _json = json;
 }

 public VideoProcessor(ILogger logger, IMediaEncoder mediaEncoder, IFileSystem fileSystem, IApplicationPaths appPaths, ILibraryMonitor libraryMonitor)
 {
     _logger = logger;
     _mediaEncoder = mediaEncoder;
     _fileSystem = fileSystem;
     _appPaths = appPaths;
     _libraryMonitor = libraryMonitor;
 }

 public VideoImageProvider(IIsoManager isoManager, IMediaEncoder mediaEncoder, IServerConfigurationManager config, ILibraryManager libraryManager, ILogger logger)
 {
     _isoManager = isoManager;
     _mediaEncoder = mediaEncoder;
     _config = config;
     _libraryManager = libraryManager;
     _logger = logger;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="BaseStreamingService" /> class.
 /// </summary>
 /// <param name="appPaths">The app paths.</param>
 /// <param name="userManager">The user manager.</param>
 /// <param name="libraryManager">The library manager.</param>
 /// <param name="isoManager">The iso manager.</param>
 /// <param name="mediaEncoder">The media encoder.</param>
 protected BaseStreamingService(IServerApplicationPaths appPaths, IUserManager userManager, ILibraryManager libraryManager, IIsoManager isoManager, IMediaEncoder mediaEncoder)
 {
     ApplicationPaths = appPaths;
     UserManager = userManager;
     LibraryManager = libraryManager;
     IsoManager = isoManager;
     MediaEncoder = mediaEncoder;
 }

 public EncodingManager(IServerConfigurationManager config, IFileSystem fileSystem, ILogger logger, IItemRepository itemRepo, IMediaEncoder encoder)
 {
     _config = config;
     _fileSystem = fileSystem;
     _logger = logger;
     _itemRepo = itemRepo;
     _encoder = encoder;
 }

 public RokuScheduledTask(ILibraryManager libraryManager, ILogger logger, IMediaEncoder mediaEncoder, IFileSystem fileSystem, IApplicationPaths appPaths, ILibraryMonitor libraryMonitor)
 {
     _libraryManager = libraryManager;
     _logger = logger;
     _mediaEncoder = mediaEncoder;
     _fileSystem = fileSystem;
     _appPaths = appPaths;
     _libraryMonitor = libraryMonitor;
 }

 public BifService(ILibraryManager libraryManager, IMediaEncoder mediaEncoder, IFileSystem fileSystem, ILogger logger, IApplicationPaths appPaths, ILibraryMonitor libraryMonitor)
 {
     _libraryManager = libraryManager;
     _mediaEncoder = mediaEncoder;
     _fileSystem = fileSystem;
     _logger = logger;
     _appPaths = appPaths;
     _libraryMonitor = libraryMonitor;
 }

 public LiveTvMediaSourceProvider(ILiveTvManager liveTvManager, IJsonSerializer jsonSerializer, ILogManager logManager, IMediaSourceManager mediaSourceManager, IMediaEncoder mediaEncoder, IServerApplicationHost appHost)
 {
     _liveTvManager = liveTvManager;
     _jsonSerializer = jsonSerializer;
     _mediaSourceManager = mediaSourceManager;
     _mediaEncoder = mediaEncoder;
     _appHost = appHost;
     _logger = logManager.GetLogger(GetType().Name);
 }

 public SyncJobProcessor(ILibraryManager libraryManager, ISyncRepository syncRepo, ISyncManager syncManager, ILogger logger, IUserManager userManager, ITVSeriesManager tvSeriesManager, IMediaEncoder mediaEncoder)
 {
     _libraryManager = libraryManager;
     _syncRepo = syncRepo;
     _syncManager = syncManager;
     _logger = logger;
     _userManager = userManager;
     _tvSeriesManager = tvSeriesManager;
     _mediaEncoder = mediaEncoder;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="BaseStreamingService" /> class.
 /// </summary>
 /// <param name="appPaths">The app paths.</param>
 /// <param name="userManager">The user manager.</param>
 /// <param name="libraryManager">The library manager.</param>
 /// <param name="isoManager">The iso manager.</param>
 /// <param name="mediaEncoder">The media encoder.</param>
 protected BaseStreamingService(IServerApplicationPaths appPaths, IUserManager userManager, ILibraryManager libraryManager, IIsoManager isoManager, IMediaEncoder mediaEncoder, IDtoService dtoService, IFileSystem fileSystem)
 {
     FileSystem = fileSystem;
     DtoService = dtoService;
     ApplicationPaths = appPaths;
     UserManager = userManager;
     LibraryManager = libraryManager;
     IsoManager = isoManager;
     MediaEncoder = mediaEncoder;
 }

 public EncodedRecorder(ILogger logger, IFileSystem fileSystem, IMediaEncoder mediaEncoder, IServerApplicationPaths appPaths, IJsonSerializer json, LiveTvOptions liveTvOptions, IHttpClient httpClient)
 {
     _logger = logger;
     _fileSystem = fileSystem;
     _mediaEncoder = mediaEncoder;
     _appPaths = appPaths;
     _json = json;
     _liveTvOptions = liveTvOptions;
     _httpClient = httpClient;
 }

 public EncodingManager(IFileSystem fileSystem, 
     ILogger logger, 
     IMediaEncoder encoder, 
     IChapterManager chapterManager)
 {
     _fileSystem = fileSystem;
     _logger = logger;
     _encoder = encoder;
     _chapterManager = chapterManager;
 }