Improved album art handling

UnknownException · UnknownException · commit 712c54fdefaa · 2025-03-16T11:46:42.000+01:00
Fetch album covers concurrently on the cover art tab.
Resizing of embedded art now uses the 'maxAlbumArtSize' setting to stay within bounds.
diff --git a/CUERipper.Avalonia/Configuration/Abstractions/ICUEConfigFacade.cs b/CUERipper.Avalonia/Configuration/Abstractions/ICUEConfigFacade.cs
@@ -57,6 +57,7 @@ public interface ICUEConfigFacade
         bool CreateEACLog { get; set; }
         bool CreateM3U { get; set; }
         bool EmbedAlbumArt { get; set; }
+        int MaxAlbumArtSize { get; set; }
         bool EjectAfterRip { get; set; }
         bool DisableEjectDisc { get; set; }
         string TrackFilenameFormat { get; set; }
diff --git a/CUERipper.Avalonia/Configuration/CUEConfigFacade.cs b/CUERipper.Avalonia/Configuration/CUEConfigFacade.cs
@@ -68,6 +68,7 @@ public class CUEConfigFacade : ICUEConfigFacade
         public bool CreateEACLog { get => _cueConfig.createEACLOG; set => _cueConfig.createEACLOG = value; }
         public bool CreateM3U { get => _cueConfig.createM3U; set => _cueConfig.createM3U = value; }
         public bool EmbedAlbumArt { get => _cueConfig.embedAlbumArt; set => _cueConfig.embedAlbumArt = value; }
+        public int MaxAlbumArtSize { get => _cueConfig.maxAlbumArtSize; set => _cueConfig.maxAlbumArtSize = value; }
         public bool EjectAfterRip { get => _cueConfig.ejectAfterRip; set => _cueConfig.ejectAfterRip = value; }
         public bool DisableEjectDisc { get => _cueConfig.disableEjectDisc; set => _cueConfig.disableEjectDisc = value; }
         public string TrackFilenameFormat { get => _cueConfig.trackFilenameFormat; set => _cueConfig.trackFilenameFormat = value; }
diff --git a/CUERipper.Avalonia/Constants.cs b/CUERipper.Avalonia/Constants.cs
@@ -41,18 +41,19 @@ public static class Constants
             $"%music%/%artist%/[%year% - ]%album%[ '('disc %discnumberandname%')'][' ('%releasedateandlabel%')'][' ('%unique%')']/%artist% - %album%{CueExtension}"
         ];
         public const int MaxPathFormats = 10; // Based on the original CUERipper limit
-
+        
         public const string ApplicationName = $"CUERipper.Avalonia {CUESheet.CUEToolsVersion}";
 
         public const string PathNoto = "avares://CUERipper.Avalonia/Assets/noto-emoji/32/";
         public const string PathImageCache = "./CUERipper/.AlbumCache/";
         public const string PathUpdate = "./.cueupdate/";
 
-        public const int EmbeddedImageMaxDimension = 500;
         public const int HiResImageMaxDimension = 2048;
 
         public const string GithubApiUri = "https://api.github.com/repos/gchudov/cuetools.net/releases";
         public const string UserAgent = "Mozilla/5.0";
         public const string UpdaterExecutable = "CUETools.Updater.exe";
+
+        public const int MaxCoverFetchConcurrency = 4;
     }
 }
diff --git a/CUERipper.Avalonia/Services/CUERipperService.cs b/CUERipper.Avalonia/Services/CUERipperService.cs
@@ -407,10 +407,10 @@ public Task RipAudioTracks(RipSettings ripSettings, CancellationToken ct)
                 if (albumCover != null)
                 {
                     Bitmap? embeddedArtwork = null; 
-                    if (albumCover.PixelSize.Width > Constants.EmbeddedImageMaxDimension
-                        || albumCover.PixelSize.Height > Constants.EmbeddedImageMaxDimension)
+                    if (albumCover.PixelSize.Width > _config.MaxAlbumArtSize
+                        || albumCover.PixelSize.Height > _config.MaxAlbumArtSize)
                     {
-                        embeddedArtwork = albumCover.ContainedResize(Constants.EmbeddedImageMaxDimension);
+                        embeddedArtwork = albumCover.ContainedResize(_config.MaxAlbumArtSize);
                     }
 
                     byte[] byteArray = [];
diff --git a/CUERipper.Avalonia/ViewModels/Bindings/OptionProxies/Abstractions/OptionProxy.cs b/CUERipper.Avalonia/ViewModels/Bindings/OptionProxies/Abstractions/OptionProxy.cs
@@ -35,6 +35,7 @@ public abstract class OptionProxy<T> : IOptionProxy
 
         protected abstract string GetStringFromValue(T val);
         protected abstract T GetValueFromString(string str);
+        protected virtual T ContainWithinRange(T value) => value;
 
         private string _viewValue = string.Empty;
         public string Value
@@ -57,11 +58,13 @@ public string Value
             set
             {
                 if (value == null || IsReadOnly) return;
-                _viewValue = value;
 
                 try
                 {
-                    T actualValue = GetValueFromString(_viewValue);
+                    T actualValue = GetValueFromString(value);
+                    actualValue = ContainWithinRange(actualValue);
+
+                    _viewValue = GetStringFromValue(actualValue);
                     Accessor.Set(actualValue);
                 }
                 catch (TypeInitializationException ex)
diff --git a/CUERipper.Avalonia/ViewModels/Bindings/OptionProxies/IntOptionProxy.cs b/CUERipper.Avalonia/ViewModels/Bindings/OptionProxies/IntOptionProxy.cs
@@ -16,22 +16,38 @@ You should have received a copy of the GNU General Public License along
     with this program; if not, see <https://www.gnu.org/licenses/>.
 */
 #endregion
+using CUERipper.Avalonia.Compatibility;
 using CUERipper.Avalonia.Utilities;
 using CUERipper.Avalonia.ViewModels.Bindings.OptionProxies.Abstractions;
 
 namespace CUERipper.Avalonia.ViewModels.Bindings.OptionProxies
 {
     public class IntOptionProxy : OptionProxy<int>
     {
+        private readonly int? _minValue;
+        private readonly int? _maxValue;
+
         public IntOptionProxy(string name, int defaultValue, Accessor<int> accessor)
             : base(name, defaultValue, accessor)
         {
         }
 
+        public IntOptionProxy(string name, int defaultValue, int minValue, int maxValue, Accessor<int> accessor)
+            : base(name, defaultValue, accessor)
+        {
+            _minValue = minValue;
+            _maxValue = maxValue;
+        }
+
         protected override string GetStringFromValue(int val)
             => val.ToString();
 
         protected override int GetValueFromString(string str)
             => int.TryParse(str, out int result) ? result : Default;
+
+        protected override int ContainWithinRange(int val)
+            => _minValue != null && _maxValue != null
+                ? MathClamp.Clamp(val, _minValue.Value, _maxValue.Value)
+                : val;
     }
 }
diff --git a/CUERipper.Avalonia/Views/OptionsDialog.axaml.cs b/CUERipper.Avalonia/Views/OptionsDialog.axaml.cs
@@ -69,6 +69,11 @@ private void OnDataContextChanged(object? sender, EventArgs e)
                 , new(() => Config.CreateM3U))
             , new BoolOptionProxy("Embed album art", true
                 , new(() => Config.EmbedAlbumArt))
+            , new IntOptionProxy("Max album art size"
+                , defaultValue: CUEConfig.Constants.MaxAlbumArtSize
+                , minValue: CUEConfig.Constants.MaxAlbumArtSizeLowerBound
+                , maxValue: CUEConfig.Constants.MaxAlbumArtSizeUpperBound
+                , new(() => Config.MaxAlbumArtSize))
             , new BoolOptionProxy("Eject after rip", false
                 , new(() => Config.EjectAfterRip))
             , new BoolOptionProxy("Disable eject disc", true
@@ -86,7 +91,10 @@ private void OnDataContextChanged(object? sender, EventArgs e)
                 , new(() => Config.UseProxyMode))
             , new StringOptionProxy("Host", "127.0.0.1"
                 , new(() => Config.ProxyServer))
-            , new IntOptionProxy("Port", 8080
+            , new IntOptionProxy("Port"
+                , defaultValue: 8080
+                , minValue: 0
+                , maxValue: 65535
                 , new(() => Config.ProxyPort))
             , new StringOptionProxy("Auth user", string.Empty
                 , new(() => Config.ProxyUser))
diff --git a/CUERipper.Avalonia/Views/UserControls/CoverViewer.axaml.cs b/CUERipper.Avalonia/Views/UserControls/CoverViewer.axaml.cs
@@ -76,26 +76,35 @@ public void Feed()
 
         _thumbnailJob.Run(async (CancellationToken ct) =>
         {
-            foreach (var cover in albumCovers)
+            using var semaphore = new SemaphoreSlim(Constants.MaxCoverFetchConcurrency);
+            await Task.WhenAll(albumCovers.Select(async cover =>
             {
-                var bitmap = await _metaService.FetchImageAsync(cover.Uri150, ct);
-                if (ct.IsCancellationRequested) break;
-
-                if (bitmap != null)
+                await semaphore.WaitAsync(ct);
+                try
                 {
-                    cover.Bitmap150 = bitmap;
-                    Dispatcher.UIThread.Post(() =>
+                    var bitmap = await _metaService.FetchImageAsync(cover.Uri150, ct);
+                    if (ct.IsCancellationRequested) return;
+
+                    if (bitmap != null)
                     {
-                        if (ViewModel.AlbumCovers.None())
+                        cover.Bitmap150 = bitmap;
+                        Dispatcher.UIThread.Post(() =>
                         {
-                            cover.IsSelected = true;
-                            ViewModel.CurrentCover = cover.Bitmap150;
-                        }
-
-                        ViewModel.AlbumCovers.Add(cover);
-                    });
+                            if (ViewModel.AlbumCovers.None())
+                            {
+                                cover.IsSelected = true;
+                                ViewModel.CurrentCover = cover.Bitmap150;
+                            }
+
+                            ViewModel.AlbumCovers.Add(cover);
+                        });
+                    }
+                }
+                finally
+                {
+                    semaphore.Release();
                 }
-            }
+            }));
         });
     }
 
diff --git a/CUETools.Processor/CUEConfig.cs b/CUETools.Processor/CUEConfig.cs
@@ -4,7 +4,6 @@
 using System.Net;
 using System.Text;
 using System.Threading;
-using System.Xml;
 using CUETools.Codecs;
 using CUETools.Processor.Settings;
 using Newtonsoft.Json;
@@ -14,6 +13,13 @@ namespace CUETools.Processor
 {
     public class CUEConfig
     {
+        public static class Constants
+        {
+            public const int MaxAlbumArtSize = 300;
+            public const int MaxAlbumArtSizeLowerBound = 100;
+            public const int MaxAlbumArtSizeUpperBound = 10000;
+        }
+
         public uint fixOffsetMinimumConfidence;
         public uint fixOffsetMinimumTracksPercent;
         public uint encodeWhenConfidence;
@@ -138,7 +144,7 @@ public CUEConfig()
             CopyAlbumArt = true;
             embedAlbumArt = true;
             extractAlbumArt = true;
-            maxAlbumArtSize = 300;
+            maxAlbumArtSize = Constants.MaxAlbumArtSize;
 
             arLogToSourceFolder = false;
             arLogVerbose = true;
@@ -425,7 +431,8 @@ public void Load(SettingsReader sr)
             CopyAlbumArt = sr.LoadBoolean("CopyAlbumArt") ?? true;
             embedAlbumArt = sr.LoadBoolean("EmbedAlbumArt") ?? true;
             extractAlbumArt = sr.LoadBoolean("ExtractAlbumArt") ?? true;
-            maxAlbumArtSize = sr.LoadInt32("MaxAlbumArtSize", 100, 10000) ?? maxAlbumArtSize;
+            maxAlbumArtSize = sr.LoadInt32("MaxAlbumArtSize", Constants.MaxAlbumArtSizeLowerBound, Constants.MaxAlbumArtSizeUpperBound)
+                ?? maxAlbumArtSize;
 
             arLogToSourceFolder = sr.LoadBoolean("ArLogToSourceFolder") ?? arLogToSourceFolder;
             arLogVerbose = sr.LoadBoolean("ArLogVerbose") ?? arLogVerbose;

Original file line number	Diff line number	Diff line change
`@@ -407,10 +407,10 @@ public Task RipAudioTracks(RipSettings ripSettings, CancellationToken ct)`
`407`	`407`	`if (albumCover != null)`
`408`	`408`	`{`
`409`	`409`	`Bitmap? embeddedArtwork = null;`
`410`		`- if (albumCover.PixelSize.Width > Constants.EmbeddedImageMaxDimension`
`411`		`- \|\| albumCover.PixelSize.Height > Constants.EmbeddedImageMaxDimension)`
	`410`	`+ if (albumCover.PixelSize.Width > _config.MaxAlbumArtSize`
	`411`	`+ \|\| albumCover.PixelSize.Height > _config.MaxAlbumArtSize)`
`412`	`412`	`{`
`413`		`- embeddedArtwork = albumCover.ContainedResize(Constants.EmbeddedImageMaxDimension);`
	`413`	`+ embeddedArtwork = albumCover.ContainedResize(_config.MaxAlbumArtSize);`
`414`	`414`	`}`
`415`	`415`
`416`	`416`	`byte[] byteArray = [];`