Improved AudioConverter lossless and lossy rules

Author: Meyn

Tubifarry/Core/Model/AudioMetadataHandler.cs

@@ -381,6 +381,45 @@ public bool TryEmbedMetadata(AlbumInfo albumInfo, AlbumSongInfo trackInfo, Relea
             }
         }
 
+        /// <summary>
+        /// Checks if the specified audio format is supported for encoding by FFmpeg.
+        /// </summary>
+        /// <param name="format">The audio format to check</param>
+        /// <returns>True if the format can be used as a conversion target, false otherwise</returns>
+        public static bool IsTargetFormatSupportedForEncoding(AudioFormat format) => BaseConversionParameters.ContainsKey(format);
+
+
+        /// <summary>
+        /// Gets the actual audio codec from a file using FFmpeg and returns the corresponding AudioFormat.
+        /// </summary>
+        /// <param name="filePath">Path to the audio file</param>
+        /// <returns>AudioFormat enum value or AudioFormat.Unknown if codec is not supported or detection fails</returns>
+        public static async Task<AudioFormat> GetSupportedCodecAsync(string filePath)
+        {
+            try
+            {
+                IMediaInfo mediaInfo = await FFmpeg.GetMediaInfo(filePath);
+                IAudioStream? audioStream = mediaInfo.AudioStreams.FirstOrDefault();
+
+                if (audioStream == null)
+                {
+                    NzbDroneLogger.GetLogger(typeof(AudioMetadataHandler)).Debug("No audio stream found in file: {0}", filePath);
+                    return AudioFormat.Unknown;
+                }
+
+                string codec = audioStream.Codec.ToLower();
+                AudioFormat format = AudioFormatHelper.GetAudioFormatFromCodec(codec);
+
+                NzbDroneLogger.GetLogger(typeof(AudioMetadataHandler)).Trace("Detected codec '{0}' as format '{1}' for file: {2}", codec, format, filePath);
+                return format;
+            }
+            catch (Exception ex)
+            {
+                NzbDroneLogger.GetLogger(typeof(AudioMetadataHandler)).Error(ex, "Failed to detect codec for file: {0}", filePath);
+                return AudioFormat.Unknown;
+            }
+        }
+
         public static bool CheckFFmpegInstalled()
         {
             if (_isFFmpegInstalled.HasValue)

Tubifarry/Core/Utilities/AudioFormat.cs

@@ -17,7 +17,8 @@ public enum AudioFormat
         MIDI,
         AMR,
         WMA,
-        ALAC
+        ALAC,
+        APE
     }
 
     internal static class AudioFormatHelper
@@ -92,6 +93,7 @@ internal static class AudioFormatHelper
             "ac3" => ".ac3",
             "alac" => ".m4a",
             "vorbis" => ".ogg",
+            "ape" => ".ape",
             "pcm_s16le" or "pcm_s24le" or "pcm_s32le" => ".wav",
             _ => ".aac" // Default to AAC if the codec is unknown
         };
@@ -113,6 +115,7 @@ internal static class AudioFormatHelper
             "amr" => AudioFormat.AMR,
             "wma" => AudioFormat.WMA,
             "alac" => AudioFormat.ALAC,
+            "ape" => AudioFormat.APE,
             _ => AudioFormat.Unknown // Default for unknown formats
         };
 
@@ -134,6 +137,7 @@ internal static class AudioFormatHelper
             AudioFormat.MP4 => ".mp4",
             AudioFormat.OGG => ".ogg",
             AudioFormat.ALAC => ".m4a",
+            AudioFormat.APE => ".ape",
             _ => ".aac" // Default to AAC if the format is unknown
         };
 
@@ -171,6 +175,7 @@ internal static class AudioFormatHelper
             "amr" => AudioFormat.AMR,
             "wma" => AudioFormat.WMA,
             "alac" => AudioFormat.ALAC,
+            "ape" => AudioFormat.APE,
             _ => AudioFormat.Unknown
         };
 

Tubifarry/Metadata/Converter/AudioConverter.cs

@@ -41,7 +41,7 @@ public override MetadataFileResult TrackMetadata(Artist artist, TrackFile trackF
 
         private async Task ConvertTrack(TrackFile trackFile)
         {
-            AudioFormat trackFormat = GetTrackAudioFormat(trackFile.Path);
+            AudioFormat trackFormat = await GetTrackAudioFormatAsync(trackFile.Path);
             if (trackFormat == AudioFormat.Unknown)
                 return;
 
@@ -134,7 +134,7 @@ private async Task<bool> ShouldConvertTrack(TrackFile trackFile)
                 return false;
             }
 
-            AudioFormat trackFormat = GetTrackAudioFormat(trackFile.Path);
+            AudioFormat trackFormat = await GetTrackAudioFormatAsync(trackFile.Path);
             if (trackFormat == AudioFormat.Unknown)
                 return false;
 
@@ -169,7 +169,7 @@ private bool MatchesAnyCustomRule(AudioFormat trackFormat, int? currentBitrate)
 
         private bool IsRuleMatching(ConversionRule rule, AudioFormat trackFormat, int? currentBitrate)
         {
-            bool formatMatches = rule.IsGlobalRule || rule.SourceFormat == trackFormat;
+            bool formatMatches = rule.MatchesFormat(trackFormat);
             bool bitrateMatches = rule.MatchesBitrate(currentBitrate);
             if (formatMatches && bitrateMatches)
             {
@@ -179,9 +179,25 @@ private bool IsRuleMatching(ConversionRule rule, AudioFormat trackFormat, int? c
             return false;
         }
 
-        private AudioFormat GetTrackAudioFormat(string trackPath)
+        private async Task<AudioFormat> GetTrackAudioFormatAsync(string trackPath)
         {
-            AudioFormat trackFormat = AudioFormatHelper.GetAudioCodecFromExtension(Path.GetExtension(trackPath));
+            string extension = Path.GetExtension(trackPath);
+
+            // For .m4a files, use codec detection since they can contain AAC or ALAC
+            if (string.Equals(extension, ".m4a", StringComparison.OrdinalIgnoreCase))
+            {
+                AudioFormat detectedFormat = await AudioMetadataHandler.GetSupportedCodecAsync(trackPath);
+                if (detectedFormat != AudioFormat.Unknown)
+                {
+                    _logger.Trace($"Detected codec-based format {detectedFormat} for .m4a file: {trackPath}");
+                    return detectedFormat;
+                }
+
+                _logger.Warn($"Failed to detect codec for .m4a file, falling back to extension-based detection: {trackPath}");
+            }
+
+            // For all other extensions, use extension-based detection
+            AudioFormat trackFormat = AudioFormatHelper.GetAudioCodecFromExtension(extension);
             if (trackFormat == AudioFormat.Unknown)
                 _logger.Warn($"Unknown audio format for track: {trackPath}");
             return trackFormat;
@@ -205,6 +221,7 @@ private static string FormatDescriptionWithBitrate(AudioFormat format, int? bitr
             AudioFormat.FLAC => Settings.ConvertFLAC,
             AudioFormat.WAV => Settings.ConvertWAV,
             AudioFormat.Opus => Settings.ConvertOpus,
+            AudioFormat.APE => Settings.ConvertOther,
             AudioFormat.Vorbis => Settings.ConvertOther,
             AudioFormat.OGG => Settings.ConvertOther,
             AudioFormat.WMA => Settings.ConvertOther,

Tubifarry/Metadata/Converter/BitrateRules.cs

@@ -1,6 +1,7 @@
 using NLog;
 using NzbDrone.Common.Instrumentation;
 using System.Text.RegularExpressions;
+using Tubifarry.Core.Model;
 using Tubifarry.Core.Utilities;
 
 namespace Tubifarry.Metadata.Converter
@@ -14,7 +15,12 @@ public class ConversionRule
         public int? TargetBitrate { get; set; }
         public bool IsArtistRule { get; set; }
 
-        public bool IsGlobalRule => SourceFormat.ToString().Equals(RuleParser.GlobalRuleIdentifier, StringComparison.OrdinalIgnoreCase);
+        // Track the type of category rule
+        public bool IsGlobalRule { get; set; }
+        public bool IsLossyRule { get; set; }
+        public bool IsLosslessRule { get; set; }
+
+        public bool IsCategoryRule => IsGlobalRule || IsLossyRule || IsLosslessRule;
 
         public bool MatchesBitrate(int? currentBitrate)
         {
@@ -26,6 +32,20 @@ public bool MatchesBitrate(int? currentBitrate)
             return EvaluateBitrateCondition(currentBitrate.Value);
         }
 
+        public bool MatchesFormat(AudioFormat trackFormat)
+        {
+            if (IsGlobalRule)
+                return true;
+
+            if (IsLossyRule)
+                return AudioFormatHelper.IsLossyFormat(trackFormat);
+
+            if (IsLosslessRule)
+                return !AudioFormatHelper.IsLossyFormat(trackFormat);
+
+            return SourceFormat == trackFormat;
+        }
+
         private bool HasBitrateConstraints() => SourceBitrateOperator.HasValue && SourceBitrateValue.HasValue;
 
         private bool EvaluateBitrateCondition(int currentBitrate)
@@ -51,7 +71,16 @@ private bool EvaluateBitrateCondition(int currentBitrate)
 
         private string FormatSourcePart()
         {
-            string source = SourceFormat.ToString();
+            string source;
+            if (IsGlobalRule)
+                source = RuleParser.GlobalRuleIdentifier;
+            else if (IsLossyRule)
+                source = RuleParser.LossyRuleIdentifier;
+            else if (IsLosslessRule)
+                source = RuleParser.LosslessRuleIdentifier;
+            else
+                source = SourceFormat.ToString();
+
             if (HasBitrateConstraints())
                 source += GetOperatorSymbol() + SourceBitrateValue!.Value;
             return source;
@@ -117,6 +146,8 @@ public enum ComparisonOperator
     public static class RuleParser
     {
         public const string GlobalRuleIdentifier = "all";
+        public const string LossyRuleIdentifier = "lossy";
+        public const string LosslessRuleIdentifier = "lossless";
         public const string NoConversionTag = "no-conversion";
         private static readonly Regex SourceFormatPattern = new(@"^([a-zA-Z0-9]+)(?:([!<>=]{1,2})(\d+))?$", RegexOptions.Compiled);
         private static readonly Regex TargetFormatPattern = new(@"^([a-zA-Z0-9]+)(?::(\d+)k?)?$", RegexOptions.Compiled);
@@ -193,6 +224,13 @@ private static bool ParseSourcePart(string sourceKey, ConversionRule rule)
 
             if (sourceMatch.Groups[2].Success && sourceMatch.Groups[3].Success)
             {
+                // Category rules (all, lossy, lossless) cannot have bitrate constraints
+                if (rule.IsCategoryRule)
+                {
+                    _logger.Warn("Invalid: Bitrate constraints not applicable to category rules (all, lossy, lossless)");
+                    return false;
+                }
+
                 if (!AudioFormatHelper.IsLossyFormat(rule.SourceFormat))
                 {
                     _logger.Warn("Invalid: Bitrate constraints not applicable to lossless format");
@@ -211,6 +249,21 @@ private static bool ParseSourceFormat(string formatName, ConversionRule rule)
             if (string.Equals(formatName, GlobalRuleIdentifier, StringComparison.OrdinalIgnoreCase))
             {
                 rule.SourceFormat = AudioFormat.Unknown;
+                rule.IsGlobalRule = true;
+                return true;
+            }
+
+            if (string.Equals(formatName, LossyRuleIdentifier, StringComparison.OrdinalIgnoreCase))
+            {
+                rule.SourceFormat = AudioFormat.Unknown;
+                rule.IsLossyRule = true;
+                return true;
+            }
+
+            if (string.Equals(formatName, LosslessRuleIdentifier, StringComparison.OrdinalIgnoreCase))
+            {
+                rule.SourceFormat = AudioFormat.Unknown;
+                rule.IsLosslessRule = true;
                 return true;
             }
 
@@ -264,6 +317,12 @@ private static bool ParseTargetFormat(string formatName, ConversionRule rule)
                 return false;
             }
 
+            if (!AudioMetadataHandler.IsTargetFormatSupportedForEncoding(targetFormat))
+            {
+                _logger.Warn("Target format {0} is not supported for encoding by FFmpeg", targetFormat);
+                return false;
+            }
+
             rule.TargetFormat = targetFormat;
             return true;
         }