major refactoring

FFMpegCore.Extensions.Downloader/Enums/FFMpegBinaries.cs

@@ -0,0 +1,9 @@
+namespace FFMpegCore.Extensions.Downloader.Enums;
+
+[Flags]
+public enum FFMpegBinaries : ushort
+{
+    FFMpeg,
+    FFProbe,
+    FFPlay
+}

FFMpegCore.Extensions.Downloader/Enums/FFMpegVersions.cs

@@ -0,0 +1,29 @@
+using System.ComponentModel;
+
+namespace FFMpegCore.Extensions.Downloader.Enums;
+
+public enum FFMpegVersions : ushort
+{
+    [Description("https://ffbinaries.com/api/v1/version/latest")]
+    Latest,
+    [Description("https://ffbinaries.com/api/v1/version/6.1")]
+    V6_1,
+    [Description("https://ffbinaries.com/api/v1/version/5.1")]
+    V5_1,
+    [Description("https://ffbinaries.com/api/v1/version/4.4.1")]
+    V4_4_1,
+    [Description("https://ffbinaries.com/api/v1/version/4.2.1")]
+    V4_2_1,
+    [Description("https://ffbinaries.com/api/v1/version/4.2")]
+    V4_2,
+    [Description("https://ffbinaries.com/api/v1/version/4.1")]
+    V4_1,
+    [Description("https://ffbinaries.com/api/v1/version/4.0")]
+    V4_0,
+    [Description("https://ffbinaries.com/api/v1/version/3.4")]
+    V3_4,
+    [Description("https://ffbinaries.com/api/v1/version/3.3")]
+    V3_3,
+    [Description("https://ffbinaries.com/api/v1/version/3.2")]
+    V3_2
+}

FFMpegCore.Extensions.Downloader/Enums/SupportedPlatforms.cs

@@ -0,0 +1,13 @@
+namespace FFMpegCore.Extensions.Downloader.Enums;
+
+public enum SupportedPlatforms : ushort
+{
+    Windows64,
+    Windows32,
+    Linux64,
+    Linux32,
+    LinuxArmhf,
+    LinuxArmel,
+    LinuxArm64,
+    Osx64
+}

FFMpegCore.Extensions.Downloader/Exceptions/FFMpegDownloaderException.cs

@@ -0,0 +1,18 @@
+namespace FFMpegCore.Extensions.Downloader.Exceptions;
+
+/// <summary>
+///     Custom exception for FFMpegDownloader
+/// </summary>
+public class FFMpegDownloaderException : Exception
+{
+    public string Detail { get; set; } = "";
+
+    public FFMpegDownloaderException(string message) : base(message)
+    {
+    }
+
+    public FFMpegDownloaderException(string message, string detail) : base(message)
+    {
+        Detail = detail;
+    }
+}

FFMpegCore.Extensions.Downloader/Extensions/EnumExtensions.cs

@@ -0,0 +1,21 @@
+using System.ComponentModel;
+
+namespace FFMpegCore.Extensions.Downloader.Extensions;
+
+internal static class EnumExtensions
+{
+    public static string GetDescription(this Enum enumValue)
+    {
+        var field = enumValue.GetType().GetField(enumValue.ToString());
+        if (field == null)
+            return enumValue.ToString();
+
+        var attributes = field.GetCustomAttributes(typeof(DescriptionAttribute), false);
+        if (Attribute.GetCustomAttribute(field, typeof(DescriptionAttribute)) is DescriptionAttribute attribute)
+        {
+            return attribute.Description;
+        }
+
+        return enumValue.ToString();
+    }
+}

FFMpegCore.Extensions.Downloader/FFMpegDownloader.cs

@@ -1,51 +1,11 @@
-using System.IO.Compression;
+using FFMpegCore.Extensions.Downloader.Enums;
-using System.Net;
+using FFMpegCore.Extensions.Downloader.Exceptions;
-using System.Runtime.InteropServices;
+using FFMpegCore.Extensions.Downloader.Services;
-using System.Text.Json;
-using System.Text.Json.Serialization;
 
 namespace FFMpegCore.Extensions.Downloader;
 
-/// <summary>
-///     Downloads the latest FFMpeg suite binaries from ffbinaries.com.
-/// </summary>
 public class FFMpegDownloader
 {
-    [Flags]
-    public enum FFMpegBinaries : ushort
-    {
-        FFMpeg,
-        FFProbe,
-        FFPlay
-    }
-
-    public enum FFMpegVersions : ushort
-    {
-        Latest,
-        V6_1,
-        V5_1,
-        V4_4_1,
-        V4_2_1,
-        V4_2,
-        V4_1,
-        V4_0,
-        V3_4,
-        V3_3,
-        V3_2
-    }
-
-    public enum PlatformOverride : short
-    {
-        Windows64,
-        Windows32,
-        Linux64,
-        Linux32,
-        LinuxArmhf,
-        LinuxArmel,
-        LinuxArm64,
-        Osx64
-    }
-
     /// <summary>
     ///     Download the latest FFMpeg suite binaries for current platform
     /// </summary>
@@ -56,221 +16,39 @@ public class FFMpegDownloader
     public static async Task<List<string>> DownloadFFMpegSuite(
         FFMpegVersions version = FFMpegVersions.Latest,
         FFMpegBinaries binaries = FFMpegBinaries.FFMpeg | FFMpegBinaries.FFProbe,
-        PlatformOverride? platformOverride = null)
+        SupportedPlatforms? platformOverride = null)
     {
-        var versionInfo = await GetVersionInfo(version);
+        // get all available versions
+        var versionInfo = await FFbinariesService.GetVersionInfo(version);
+        
+        // get the download info for the current platform
         var downloadInfo = versionInfo.BinaryInfo?.GetCompatibleDownloadInfo(platformOverride) ??
                            throw new FFMpegDownloaderException("Failed to get compatible download info");
         
         var successList = new List<string>();
         
-        // if ffmpeg is selected
+        // download ffmpeg if selected
         if (binaries.HasFlag(FFMpegBinaries.FFMpeg) && downloadInfo.FFMpeg is not null)
         {
-            var zipStream = DownloadFileAsSteam(new Uri(downloadInfo.FFMpeg));
+            var zipStream = FFbinariesService.DownloadFileAsSteam(new Uri(downloadInfo.FFMpeg));
-            successList.AddRange(ExtractZipAndSave(zipStream));
+            successList.AddRange(FFbinariesService.ExtractZipAndSave(zipStream));
         }
 
-        // if ffprobe is selected
+        // download ffprobe if selected
         if (binaries.HasFlag(FFMpegBinaries.FFProbe) && downloadInfo.FFProbe is not null)
         {
-            var zipStream = DownloadFileAsSteam(new Uri(downloadInfo.FFProbe));
+            var zipStream = FFbinariesService.DownloadFileAsSteam(new Uri(downloadInfo.FFProbe));
-            successList.AddRange(ExtractZipAndSave(zipStream));
+            successList.AddRange(FFbinariesService.ExtractZipAndSave(zipStream));
         }
 
-        // if ffplay is selected
+        // download ffplay if selected
         if (binaries.HasFlag(FFMpegBinaries.FFPlay) && downloadInfo.FFPlay is not null)
         {
-            var zipStream = DownloadFileAsSteam(new Uri(downloadInfo.FFPlay));
+            var zipStream = FFbinariesService.DownloadFileAsSteam(new Uri(downloadInfo.FFPlay));
-            successList.AddRange(ExtractZipAndSave(zipStream));
+            successList.AddRange(FFbinariesService.ExtractZipAndSave(zipStream));
         }
 
         return successList;
     }
-
-    /// <summary>
-    ///     Download file from uri
-    /// </summary>
-    /// <param name="address">uri of the file</param>
-    /// <returns></returns>
-    private static MemoryStream DownloadFileAsSteam(Uri address)
-    {
-        var client = new WebClient();
-        var fileStream = new MemoryStream(client.DownloadData(address));
-        fileStream.Position = 0;
-
-        return fileStream;
-    }
-
-    /// <summary>
-    ///     Extracts the binaries from the zip stream and saves them to the current binary folder
-    /// </summary>
-    /// <param name="zipStream">steam of the zip file</param>
-    /// <returns></returns>
-    private static IEnumerable<string> ExtractZipAndSave(Stream zipStream)
-    {
-        using var archive = new ZipArchive(zipStream, ZipArchiveMode.Read);
-        List<string> files = new();
-        foreach (var entry in archive.Entries)
-        {
-            if (entry.Name is "ffmpeg" or "ffmpeg.exe" or "ffprobe.exe" or "ffprobe" or "ffplay.exe" or "ffplay")
-            {
-                entry.ExtractToFile(Path.Combine(GlobalFFOptions.Current.BinaryFolder, entry.Name), true);
-                files.Add(Path.Combine(GlobalFFOptions.Current.BinaryFolder, entry.Name));
-            }
-        }
-
-        return files;
-    }
-
-    #region FFbinaries api
-
-    private class DownloadInfo
-    {
-        [JsonPropertyName("ffmpeg")] public string? FFMpeg { get; set; }
-
-        [JsonPropertyName("ffprobe")] public string? FFProbe { get; set; }
-
-        [JsonPropertyName("ffplay")] public string? FFPlay { get; set; }
-    }
-
-    private class BinaryInfo
-    {
-        [JsonPropertyName("windows-64")] public DownloadInfo? Windows64 { get; set; }
-
-        [JsonPropertyName("windows-32")] public DownloadInfo? Windows32 { get; set; }
-
-        [JsonPropertyName("linux-32")] public DownloadInfo? Linux32 { get; set; }
-
-        [JsonPropertyName("linux-64")] public DownloadInfo? Linux64 { get; set; }
-
-        [JsonPropertyName("linux-armhf")] public DownloadInfo? LinuxArmhf { get; set; }
-
-        [JsonPropertyName("linux-armel")] public DownloadInfo? LinuxArmel { get; set; }
-
-        [JsonPropertyName("linux-arm64")] public DownloadInfo? LinuxArm64 { get; set; }
-
-        [JsonPropertyName("osx-64")] public DownloadInfo? Osx64 { get; set; }
-
-        /// <summary>
-        ///     Automatically get the compatible download info for current os and architecture
-        /// </summary>
-        /// <param name="platformOverride"></param>
-        /// <returns></returns>
-        /// <exception cref="ArgumentOutOfRangeException"></exception>
-        /// <exception cref="PlatformNotSupportedException"></exception>
-        public DownloadInfo? GetCompatibleDownloadInfo(PlatformOverride? platformOverride = null)
-        {
-            if (platformOverride is not null)
-            {
-                return platformOverride switch
-                {
-                    PlatformOverride.Windows64 => Windows64,
-                    PlatformOverride.Windows32 => Windows32,
-                    PlatformOverride.Linux64 => Linux64,
-                    PlatformOverride.Linux32 => Linux32,
-                    PlatformOverride.LinuxArmhf => LinuxArmhf,
-                    PlatformOverride.LinuxArmel => LinuxArmel,
-                    PlatformOverride.LinuxArm64 => LinuxArm64,
-                    PlatformOverride.Osx64 => Osx64,
-                    _ => throw new ArgumentOutOfRangeException(nameof(platformOverride), platformOverride, null)
-                };
-            }
-
-            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-            {
-                return RuntimeInformation.OSArchitecture == Architecture.X64 ? Windows64 : Windows32;
-            }
-
-            if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
-            {
-                return RuntimeInformation.OSArchitecture switch
-                {
-                    Architecture.X86 => Linux32,
-                    Architecture.X64 => Linux64,
-                    Architecture.Arm => LinuxArmhf,
-                    Architecture.Arm64 => LinuxArm64,
-                    _ => LinuxArmel
-                };
-            }
-
-            if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
-            {
-                return Osx64;
-            }
-
-            throw new PlatformNotSupportedException("Unsupported OS or Architecture");
-        }
-    }
-
-    private class VersionInfo
-    {
-        [JsonPropertyName("version")] public string? Version { get; set; }
-
-        [JsonPropertyName("permalink")] public string? Permalink { get; set; }
-
-        [JsonPropertyName("bin")] public BinaryInfo? BinaryInfo { get; set; }
-    }
-
-    private static readonly Dictionary<FFMpegVersions, string> _FFBinariesAPIs = new()
-    {
-        { FFMpegVersions.Latest, "https://ffbinaries.com/api/v1/version/latest" },
-        { FFMpegVersions.V6_1, "https://ffbinaries.com/api/v1/version/6.1" },
-        { FFMpegVersions.V5_1, "https://ffbinaries.com/api/v1/version/5.1" },
-        { FFMpegVersions.V4_4_1, "https://ffbinaries.com/api/v1/version/4.4.1" },
-        { FFMpegVersions.V4_2_1, "https://ffbinaries.com/api/v1/version/4.2.1" },
-        { FFMpegVersions.V4_2, "https://ffbinaries.com/api/v1/version/4.2" },
-        { FFMpegVersions.V4_1, "https://ffbinaries.com/api/v1/version/4.1" },
-        { FFMpegVersions.V4_0, "https://ffbinaries.com/api/v1/version/4.0" },
-        { FFMpegVersions.V3_4, "https://ffbinaries.com/api/v1/version/3.4" },
-        { FFMpegVersions.V3_3, "https://ffbinaries.com/api/v1/version/3.3" },
-        { FFMpegVersions.V3_2, "https://ffbinaries.com/api/v1/version/3.2" }
-    };
-
-    /// <summary>
-    ///     Get version info from ffbinaries.com
-    /// </summary>
-    /// <param name="version">use to explicitly state the version of ffmpeg you want</param>
-    /// <returns></returns>
-    /// <exception cref="FFMpegDownloaderException"></exception>
-    private static async Task<VersionInfo> GetVersionInfo(FFMpegVersions version)
-    {
-        if (!_FFBinariesAPIs.TryGetValue(version, out var versionUri))
-        {
-            throw new FFMpegDownloaderException($"Invalid version selected: {version}", "contact dev");
-        }
-
-        HttpClient client = new();
-        var response = await client.GetAsync(versionUri);
-
-        if (!response.IsSuccessStatusCode)
-        {
-            throw new FFMpegDownloaderException($"Failed to get version info from {versionUri}", "network error");
-        }
-
-        var jsonString = await response.Content.ReadAsStringAsync();
-        var versionInfo = JsonSerializer.Deserialize<VersionInfo>(jsonString);
-
-        return versionInfo ??
-               throw new FFMpegDownloaderException($"Failed to deserialize version info from {versionUri}", jsonString);
-    }
-
-    #endregion
 }
 
-/// <summary>
-///     Custom exception for FFMpegDownloader
-/// </summary>
-public class FFMpegDownloaderException : Exception
-{
-    public FFMpegDownloaderException(string message) : base(message)
-    {
-    }
-
-    public FFMpegDownloaderException(string message, string detail) : base(message)
-    {
-        Detail = detail;
-    }
-
-    public string Detail { get; set; } = "";
-}

FFMpegCore.Extensions.Downloader/Models/BinaryInfo.cs

@@ -0,0 +1,82 @@
+using System.Runtime.InteropServices;
+using System.Text.Json.Serialization;
+using FFMpegCore.Extensions.Downloader.Enums;
+
+namespace FFMpegCore.Extensions.Downloader.Models;
+
+internal record BinaryInfo
+{
+    [JsonPropertyName("windows-64")] 
+    public DownloadInfo? Windows64 { get; set; }
+
+    [JsonPropertyName("windows-32")] 
+    public DownloadInfo? Windows32 { get; set; }
+
+    [JsonPropertyName("linux-32")] 
+    public DownloadInfo? Linux32 { get; set; }
+
+    [JsonPropertyName("linux-64")] 
+    public DownloadInfo? Linux64 { get; set; }
+
+    [JsonPropertyName("linux-armhf")] 
+    public DownloadInfo? LinuxArmhf { get; set; }
+
+    [JsonPropertyName("linux-armel")] 
+    public DownloadInfo? LinuxArmel { get; set; }
+
+    [JsonPropertyName("linux-arm64")] 
+    public DownloadInfo? LinuxArm64 { get; set; }
+
+    [JsonPropertyName("osx-64")] 
+    public DownloadInfo? Osx64 { get; set; }
+
+    /// <summary>
+    ///     Automatically get the compatible download info for current os and architecture
+    /// </summary>
+    /// <param name="platformOverride"></param>
+    /// <returns></returns>
+    /// <exception cref="ArgumentOutOfRangeException"></exception>
+    /// <exception cref="PlatformNotSupportedException"></exception>
+    public DownloadInfo? GetCompatibleDownloadInfo(SupportedPlatforms? platformOverride = null)
+    {
+        if (platformOverride is not null)
+        {
+            return platformOverride switch
+            {
+                SupportedPlatforms.Windows64 => Windows64,
+                SupportedPlatforms.Windows32 => Windows32,
+                SupportedPlatforms.Linux64 => Linux64,
+                SupportedPlatforms.Linux32 => Linux32,
+                SupportedPlatforms.LinuxArmhf => LinuxArmhf,
+                SupportedPlatforms.LinuxArmel => LinuxArmel,
+                SupportedPlatforms.LinuxArm64 => LinuxArm64,
+                SupportedPlatforms.Osx64 => Osx64,
+                _ => throw new ArgumentOutOfRangeException(nameof(platformOverride), platformOverride, null)
+            };
+        }
+
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+        {
+            return RuntimeInformation.OSArchitecture == Architecture.X64 ? Windows64 : Windows32;
+        }
+
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+        {
+            return RuntimeInformation.OSArchitecture switch
+            {
+                Architecture.X86 => Linux32,
+                Architecture.X64 => Linux64,
+                Architecture.Arm => LinuxArmhf,
+                Architecture.Arm64 => LinuxArm64,
+                _ => LinuxArmel
+            };
+        }
+
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+        {
+            return Osx64;
+        }
+
+        throw new PlatformNotSupportedException("Unsupported OS or Architecture");
+    }
+}

FFMpegCore.Extensions.Downloader/Models/DownloadInfo.cs

@@ -0,0 +1,15 @@
+using System.Text.Json.Serialization;
+
+namespace FFMpegCore.Extensions.Downloader.Models;
+
+internal record DownloadInfo
+{
+    [JsonPropertyName("ffmpeg")] 
+    public string? FFMpeg { get; set; }
+
+    [JsonPropertyName("ffprobe")] 
+    public string? FFProbe { get; set; }
+
+    [JsonPropertyName("ffplay")] 
+    public string? FFPlay { get; set; }
+}

FFMpegCore.Extensions.Downloader/Models/VersionInfo.cs

@@ -0,0 +1,15 @@
+using System.Text.Json.Serialization;
+
+namespace FFMpegCore.Extensions.Downloader.Models;
+
+internal record VersionInfo
+{
+    [JsonPropertyName("version")] 
+    public string? Version { get; set; }
+
+    [JsonPropertyName("permalink")] 
+    public string? Permalink { get; set; }
+
+    [JsonPropertyName("bin")] 
+    public BinaryInfo? BinaryInfo { get; set; }
+}

FFMpegCore.Extensions.Downloader/Services/FFbinariesService.cs

@@ -0,0 +1,75 @@
+using System.IO.Compression;
+using System.Net;
+using System.Text.Json;
+using FFMpegCore.Extensions.Downloader.Enums;
+using FFMpegCore.Extensions.Downloader.Exceptions;
+using FFMpegCore.Extensions.Downloader.Extensions;
+using FFMpegCore.Extensions.Downloader.Models;
+
+namespace FFMpegCore.Extensions.Downloader.Services;
+
+/// <summary>
+///     Service to interact with ffbinaries.com API
+/// </summary>
+internal class FFbinariesService
+{
+    /// <summary>
+    ///     Get version info from ffbinaries.com
+    /// </summary>
+    /// <param name="version">use to explicitly state the version of ffmpeg you want</param>
+    /// <returns></returns>
+    /// <exception cref="FFMpegDownloaderException"></exception>
+    internal static async Task<VersionInfo> GetVersionInfo(FFMpegVersions version)
+    {
+        var versionUri = version.GetDescription();
+
+        HttpClient client = new();
+        var response = await client.GetAsync(versionUri);
+
+        if (!response.IsSuccessStatusCode)
+        {
+            throw new FFMpegDownloaderException($"Failed to get version info from {versionUri}", "network error");
+        }
+
+        var jsonString = await response.Content.ReadAsStringAsync();
+        var versionInfo = JsonSerializer.Deserialize<VersionInfo>(jsonString);
+
+        return versionInfo ??
+               throw new FFMpegDownloaderException($"Failed to deserialize version info from {versionUri}", jsonString);
+    }
+    
+    /// <summary>
+    ///     Download file from uri
+    /// </summary>
+    /// <param name="address">uri of the file</param>
+    /// <returns></returns>
+    internal static MemoryStream DownloadFileAsSteam(Uri address)
+    {
+        var client = new WebClient();
+        var fileStream = new MemoryStream(client.DownloadData(address));
+        fileStream.Position = 0;
+
+        return fileStream;
+    }
+
+    /// <summary>
+    ///     Extracts the binaries from the zip stream and saves them to the current binary folder
+    /// </summary>
+    /// <param name="zipStream">steam of the zip file</param>
+    /// <returns></returns>
+    internal static IEnumerable<string> ExtractZipAndSave(Stream zipStream)
+    {
+        using var archive = new ZipArchive(zipStream, ZipArchiveMode.Read);
+        List<string> files = new();
+        foreach (var entry in archive.Entries)
+        {
+            if (entry.Name is "ffmpeg" or "ffmpeg.exe" or "ffprobe.exe" or "ffprobe" or "ffplay.exe" or "ffplay")
+            {
+                entry.ExtractToFile(Path.Combine(GlobalFFOptions.Current.BinaryFolder, entry.Name), true);
+                files.Add(Path.Combine(GlobalFFOptions.Current.BinaryFolder, entry.Name));
+            }
+        }
+
+        return files;
+    }
+}

FFMpegCore.Test/DownloaderTests.cs

@@ -1,4 +1,5 @@
 using FFMpegCore.Extensions.Downloader;
+using FFMpegCore.Extensions.Downloader.Enums;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace FFMpegCore.Test;
@@ -9,14 +10,14 @@ public class DownloaderTests
     [TestMethod]
     public void GetAllLatestSuiteTest()
     {
-        var binaries = FFMpegDownloader.DownloadFFMpegSuite(binaries: FFMpegDownloader.FFMpegBinaries.FFMpeg).Result;
+        var binaries = FFMpegDownloader.DownloadFFMpegSuite().Result;
-        Assert.IsTrue(binaries.Count == 1); // many platforms have only ffmpeg and ffprobe
+        Assert.IsTrue(binaries.Count == 2); // many platforms have only ffmpeg and ffprobe
     }
 
     [TestMethod]
     public void GetSpecificVersionTest()
     {
-        var binaries = FFMpegDownloader.DownloadFFMpegSuite(FFMpegDownloader.FFMpegVersions.V4_0, binaries: FFMpegDownloader.FFMpegBinaries.FFMpeg).Result;
+        var binaries = FFMpegDownloader.DownloadFFMpegSuite(FFMpegVersions.V4_0, binaries: FFMpegBinaries.FFMpeg).Result;
         Assert.IsTrue(binaries.Count == 1);
     }
 }