increment version

Fix temp file storage/deletion + a few new features:

* .tmp and .json files are again properly stored in DownloadsInProgressDirectory, and the are again used if resuming a download.
* Yellow stoplight works again.
* All audio files stored in DecryptInProgressDirectory are deleted if the conversion fails Partial / Complete files in %temp%\Libation are not tidied / reused #144
* Added option to retain aax file Feature Request: Allow saving the original aax #187
* Add option to remove "(Unabridged)" from metadata tags Remove "(Unabridged)" from the title? #223
* Added options for mp3 encoding
* Add option to create cue sheet
* Prevent same book being decrypted more than once at a time
* Made a new settings tab for all audio file editing/fixing options.

AaxDecrypter/AaxDecrypter.csproj

@@ -5,8 +5,8 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="AAXClean" Version="0.3.5" />
-    <PackageReference Include="AAXClean.Codecs" Version="0.1.12" />
+    <PackageReference Include="AAXClean" Version="0.4.6" />
+    <PackageReference Include="AAXClean.Codecs" Version="0.2.7" />
   </ItemGroup>
 
   <ItemGroup>

AaxDecrypter/AaxcDownloadConvertBase.cs

@@ -8,15 +8,10 @@ namespace AaxDecrypter
 	{
 		public event EventHandler<AppleTags> RetrievedMetadata;
 
-		protected OutputFormat OutputFormat { get; }
-
 		protected AaxFile AaxFile;
 
-		protected AaxcDownloadConvertBase(string outFileName, string cacheDirectory, DownloadLicense dlLic, OutputFormat outputFormat)
-			: base(outFileName, cacheDirectory, dlLic)
-		{
-			OutputFormat = outputFormat;
-		}
+		protected AaxcDownloadConvertBase(string outFileName, string cacheDirectory, DownloadOptions dlLic)
+			: base(outFileName, cacheDirectory, dlLic) { }
 
 		/// <summary>Setting cover art by this method will insert the art into the audiobook metadata</summary>
 		public override void SetCoverArt(byte[] coverArt)
@@ -30,6 +25,36 @@ namespace AaxDecrypter
 		{
 			AaxFile = new AaxFile(InputFileStream);
 
+			if (DownloadOptions.StripUnabridged)
+			{
+				AaxFile.AppleTags.Title = AaxFile.AppleTags.TitleSansUnabridged;
+				AaxFile.AppleTags.Album = AaxFile.AppleTags.Album?.Replace(" (Unabridged)", "");
+			}
+
+			//Finishing configuring lame encoder.
+			if (DownloadOptions.OutputFormat == OutputFormat.Mp3)
+			{
+				double bitrateMultiple = 1;
+
+				if (AaxFile.AudioChannels == 2)
+				{
+					if (DownloadOptions.Downsample)
+						bitrateMultiple = 0.5;
+					else
+						DownloadOptions.LameConfig.Mode = NAudio.Lame.MPEGMode.Stereo;
+				}
+
+				if (DownloadOptions.MatchSourceBitrate)
+				{
+					int kbps = (int)(AaxFile.AverageBitrate * bitrateMultiple / 1024);
+
+					if (DownloadOptions.LameConfig.VBR is null)
+						DownloadOptions.LameConfig.BitRate = kbps;
+					else if (DownloadOptions.LameConfig.VBR == NAudio.Lame.VBRMode.ABR)
+						DownloadOptions.LameConfig.ABRRateKbps = kbps;
+				}
+			}
+
 			OnRetrievedTitle(AaxFile.AppleTags.TitleSansUnabridged);
 			OnRetrievedAuthors(AaxFile.AppleTags.FirstAuthor ?? "[unknown]");
 			OnRetrievedNarrators(AaxFile.AppleTags.Narrator ?? "[unknown]");
@@ -51,7 +76,7 @@ namespace AaxDecrypter
 
 			OnDecryptProgressUpdate(zeroProgress);
 
-			AaxFile.SetDecryptionKey(DownloadLicense.AudibleKey, DownloadLicense.AudibleIV);
+			AaxFile.SetDecryptionKey(DownloadOptions.AudibleKey, DownloadOptions.AudibleIV);
 			return zeroProgress;
 		}
 
@@ -73,7 +98,7 @@ namespace AaxDecrypter
 			if (double.IsNormal(estTimeRemaining))
 				OnDecryptTimeRemaining(TimeSpan.FromSeconds(estTimeRemaining));
 
-			var progressPercent = e.ProcessPosition.TotalSeconds / duration.TotalSeconds;
+			var progressPercent = (e.ProcessPosition / e.TotalDuration);
 
 			OnDecryptProgressUpdate(
 				new DownloadProgress

AaxDecrypter/AaxcDownloadMultiConverter.cs

@@ -18,13 +18,13 @@ namespace AaxDecrypter
         private static TimeSpan minChapterLength { get; } = TimeSpan.FromSeconds(3);
 		private List<string> multiPartFilePaths { get; } = new List<string>();
 
-        public AaxcDownloadMultiConverter(string outFileName, string cacheDirectory, DownloadLicense dlLic, OutputFormat outputFormat,
+        public AaxcDownloadMultiConverter(string outFileName, string cacheDirectory, DownloadOptions dlLic,
             Func<MultiConvertFileProperties, string> multipartFileNameCallback = null)
-			: base(outFileName, cacheDirectory, dlLic, outputFormat)
+			: base(outFileName, cacheDirectory, dlLic)
         {
             Steps = new StepSequence
             {
-                Name = "Download and Convert Aaxc To " + OutputFormat,
+                Name = "Download and Convert Aaxc To " + DownloadOptions.OutputFormat,
 
                 ["Step 1: Get Aaxc Metadata"] = Step_GetMetadata,
                 ["Step 2: Download Decrypted Audiobook"] = Step_DownloadAudiobookAsMultipleFilesPerChapter,
@@ -61,10 +61,10 @@ That naming may not be desirable for everyone, but it's an easy change to instea
         {
             var zeroProgress = Step_DownloadAudiobook_Start();
 
-            var chapters = DownloadLicense.ChapterInfo.Chapters.ToList();
+            var chapters = DownloadOptions.ChapterInfo.Chapters.ToList();
 
             // Ensure split files are at least minChapterLength in duration.
-            var splitChapters = new ChapterInfo();
+            var splitChapters = new ChapterInfo(DownloadOptions.ChapterInfo.StartOffset);
 
             var runningTotal = TimeSpan.Zero;
             string title = "";
@@ -86,40 +86,36 @@ That naming may not be desirable for everyone, but it's an easy change to instea
             // reset, just in case
             multiPartFilePaths.Clear();
 
+            ConversionResult result;
+
             AaxFile.ConversionProgressUpdate += AaxFile_ConversionProgressUpdate;
-            if (OutputFormat == OutputFormat.M4b)
-                ConvertToMultiMp4a(splitChapters);
+            if (DownloadOptions.OutputFormat == OutputFormat.M4b)
+                result = ConvertToMultiMp4a(splitChapters);
             else
-                ConvertToMultiMp3(splitChapters);
+                result = ConvertToMultiMp3(splitChapters);
             AaxFile.ConversionProgressUpdate -= AaxFile_ConversionProgressUpdate;
 
             Step_DownloadAudiobook_End(zeroProgress);
 
-            var success = !IsCanceled;
-
-            if (success)
-                foreach (var path in multiPartFilePaths)
-                    OnFileCreated(path);
-
-            return success;
+            return result == ConversionResult.NoErrorsDetected;
         }
 
-        private void ConvertToMultiMp4a(ChapterInfo splitChapters)
+        private ConversionResult ConvertToMultiMp4a(ChapterInfo splitChapters)
         {
             var chapterCount = 0;
-            AaxFile.ConvertToMultiMp4a(splitChapters, newSplitCallback =>
-                createOutputFileStream(++chapterCount, splitChapters, newSplitCallback)
-            );
+            return AaxFile.ConvertToMultiMp4a(splitChapters, newSplitCallback =>
+                createOutputFileStream(++chapterCount, splitChapters, newSplitCallback),
+            DownloadOptions.TrimOutputToChapterLength);
         }
 
-        private void ConvertToMultiMp3(ChapterInfo splitChapters)
+        private ConversionResult ConvertToMultiMp3(ChapterInfo splitChapters)
         {
             var chapterCount = 0;
-            AaxFile.ConvertToMultiMp3(splitChapters, newSplitCallback =>
+            return AaxFile.ConvertToMultiMp3(splitChapters, newSplitCallback =>
             {
                 createOutputFileStream(++chapterCount, splitChapters, newSplitCallback);
                 ((NAudio.Lame.LameConfig)newSplitCallback.UserState).ID3.Track = chapterCount.ToString();
-            });
+            }, DownloadOptions.LameConfig, DownloadOptions.TrimOutputToChapterLength);
         }
 
         private void createOutputFileStream(int currentChapter, ChapterInfo splitChapters, NewSplitCallback newSplitCallback)
@@ -138,6 +134,8 @@ That naming may not be desirable for everyone, but it's an easy change to instea
             FileUtility.SaferDelete(fileName);
 
             newSplitCallback.OutputFile = File.Open(fileName, FileMode.OpenOrCreate);
+
+            OnFileCreated(fileName);
         }
     }
 }

AaxDecrypter/AaxcDownloadSingleConverter.cs

@@ -11,12 +11,12 @@ namespace AaxDecrypter
 	{
 		protected override StepSequence Steps { get; }
 
-        public AaxcDownloadSingleConverter(string outFileName, string cacheDirectory, DownloadLicense dlLic, OutputFormat outputFormat)
-			: base(outFileName, cacheDirectory, dlLic, outputFormat)
+        public AaxcDownloadSingleConverter(string outFileName, string cacheDirectory, DownloadOptions dlLic)
+			: base(outFileName, cacheDirectory, dlLic)
         {
             Steps = new StepSequence
             {
-                Name = "Download and Convert Aaxc To " + OutputFormat,
+                Name = "Download and Convert Aaxc To " + DownloadOptions.OutputFormat,
 
                 ["Step 1: Get Aaxc Metadata"] = Step_GetMetadata,
                 ["Step 2: Download Decrypted Audiobook"] = Step_DownloadAudiobookAsSingleFile,
@@ -32,15 +32,16 @@ namespace AaxDecrypter
             FileUtility.SaferDelete(OutputFileName);
 
             var outputFile = File.Open(OutputFileName, FileMode.OpenOrCreate, FileAccess.ReadWrite);
+            OnFileCreated(OutputFileName);
 
             AaxFile.ConversionProgressUpdate += AaxFile_ConversionProgressUpdate;
             var decryptionResult
-                = OutputFormat == OutputFormat.M4b
-                ? AaxFile.ConvertToMp4a(outputFile, DownloadLicense.ChapterInfo)
-                : AaxFile.ConvertToMp3(outputFile);
+                = DownloadOptions.OutputFormat == OutputFormat.M4b
+                ? AaxFile.ConvertToMp4a(outputFile, DownloadOptions.ChapterInfo, DownloadOptions.TrimOutputToChapterLength)
+                : AaxFile.ConvertToMp3(outputFile, DownloadOptions.LameConfig, DownloadOptions.ChapterInfo, DownloadOptions.TrimOutputToChapterLength);
             AaxFile.ConversionProgressUpdate -= AaxFile_ConversionProgressUpdate;
 
-            DownloadLicense.ChapterInfo = AaxFile.Chapters;
+            DownloadOptions.ChapterInfo = AaxFile.Chapters;
 
             Step_DownloadAudiobook_End(zeroProgress);
 

AaxDecrypter/AudiobookDownloadBase.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using Dinah.Core;
 using Dinah.Core.Net.Http;
@@ -20,8 +21,9 @@ namespace AaxDecrypter
 		public event EventHandler<string> FileCreated;
 
 		protected bool IsCanceled { get; set; }
+		
 		protected string OutputFileName { get; private set; }
-		protected DownloadLicense DownloadLicense { get; }
+		protected DownloadOptions DownloadOptions { get; }
 		protected NetworkFileStream InputFileStream => (nfsPersister ??= OpenNetworkFileStream()).NetworkFileStream;
 
 		// Don't give the property a 'set'. This should have to be an obvious choice; not accidental
@@ -31,9 +33,9 @@ namespace AaxDecrypter
 		private NetworkFileStreamPersister nfsPersister;
 
 		private string jsonDownloadState { get; }
-		private string tempFile => Path.ChangeExtension(jsonDownloadState, ".tmp");
+		public string TempFilePath { get; }
 
-		protected AudiobookDownloadBase(string outFileName, string cacheDirectory, DownloadLicense dlLic)
+		protected AudiobookDownloadBase(string outFileName, string cacheDirectory, DownloadOptions dlLic)
 		{
 			OutputFileName = ArgumentValidator.EnsureNotNullOrWhiteSpace(outFileName, nameof(outFileName));
 
@@ -43,9 +45,11 @@ namespace AaxDecrypter
 
 			if (!Directory.Exists(cacheDirectory))
 				throw new DirectoryNotFoundException($"Directory does not exist: {nameof(cacheDirectory)}");
-			jsonDownloadState = Path.Combine(cacheDirectory, Path.ChangeExtension(OutputFileName, ".json"));
 
-			DownloadLicense = ArgumentValidator.EnsureNotNull(dlLic, nameof(dlLic));
+			jsonDownloadState = Path.Combine(cacheDirectory, Path.GetFileName(Path.ChangeExtension(OutputFileName, ".json")));
+			TempFilePath = Path.ChangeExtension(jsonDownloadState, ".aaxc");
+
+			DownloadOptions = ArgumentValidator.EnsureNotNull(dlLic, nameof(dlLic));
 
 			// delete file after validation is complete
 			FileUtility.SaferDelete(OutputFileName);
@@ -94,12 +98,14 @@ namespace AaxDecrypter
 
 		protected bool Step_CreateCue()
 		{
+			if (!DownloadOptions.CreateCueSheet) return true;
+
 			// not a critical step. its failure should not prevent future steps from running
 			try
 			{
 				var path = Path.ChangeExtension(OutputFileName, ".cue");
 				path = FileUtility.GetValidFilename(path);
-				File.WriteAllText(path, Cue.CreateContents(Path.GetFileName(OutputFileName), DownloadLicense.ChapterInfo));
+				File.WriteAllText(path, Cue.CreateContents(Path.GetFileName(OutputFileName), DownloadOptions.ChapterInfo));
 				OnFileCreated(path);
 			}
 			catch (Exception ex)
@@ -111,9 +117,36 @@ namespace AaxDecrypter
 
 		protected bool Step_Cleanup()
 		{
-			FileUtility.SaferDelete(jsonDownloadState);
-			FileUtility.SaferDelete(tempFile);
-			return !IsCanceled;
+			bool success = !IsCanceled;
+			if (success)
+			{
+				FileUtility.SaferDelete(jsonDownloadState);
+
+				if (DownloadOptions.AudibleKey is not null && 
+					DownloadOptions.AudibleIV is not null && 
+					DownloadOptions.RetainEncryptedFile)
+				{
+					string aaxPath = Path.ChangeExtension(TempFilePath, ".aax");
+					FileUtility.SaferMove(TempFilePath, aaxPath);
+
+					//Write aax decryption key
+					string keyPath = Path.ChangeExtension(aaxPath, ".key");
+					FileUtility.SaferDelete(keyPath);
+					File.WriteAllText(keyPath, $"Key={DownloadOptions.AudibleKey}\r\nIV={DownloadOptions.AudibleIV}");
+
+					OnFileCreated(aaxPath);
+					OnFileCreated(keyPath);
+				}
+				else
+					FileUtility.SaferDelete(TempFilePath);
+			}
+			else
+			{
+				FileUtility.SaferDelete(OutputFileName);
+			}
+
+
+			return success;
 		}
 
 		private NetworkFileStreamPersister OpenNetworkFileStream()
@@ -126,13 +159,13 @@ namespace AaxDecrypter
 				var nfsp = new NetworkFileStreamPersister(jsonDownloadState);
 				// If More than ~1 hour has elapsed since getting the download url, it will expire.
 				// The new url will be to the same file.
-				nfsp.NetworkFileStream.SetUriForSameFile(new Uri(DownloadLicense.DownloadUrl));
+				nfsp.NetworkFileStream.SetUriForSameFile(new Uri(DownloadOptions.DownloadUrl));
 				return nfsp;
 			}
 			catch
 			{
 				FileUtility.SaferDelete(jsonDownloadState);
-				FileUtility.SaferDelete(tempFile);
+				FileUtility.SaferDelete(TempFilePath);
 				return NewNetworkFilePersister();
 			}
 		}
@@ -141,10 +174,10 @@ namespace AaxDecrypter
 		{
 			var headers = new System.Net.WebHeaderCollection
 			{
-				{ "User-Agent", DownloadLicense.UserAgent }
+				{ "User-Agent", DownloadOptions.UserAgent }
 			};
 
-			var networkFileStream = new NetworkFileStream(tempFile, new Uri(DownloadLicense.DownloadUrl), 0, headers);
+			var networkFileStream = new NetworkFileStream(TempFilePath, new Uri(DownloadOptions.DownloadUrl), 0, headers);
 			return new NetworkFileStreamPersister(networkFileStream, jsonDownloadState);
 		}
 	}

AaxDecrypter/Cue.cs

@@ -14,14 +14,17 @@ namespace AaxDecrypter
 
             stringBuilder.AppendLine(GetFileLine(filePath, "MP3"));
 
+            var startOffset = chapters.StartOffset;
+
             var trackCount = 0;
             foreach (var c in chapters.Chapters)
             {
+                var startTime = c.StartOffset - startOffset;
                 trackCount++;
 
                 stringBuilder.AppendLine($"TRACK {trackCount} AUDIO");
                 stringBuilder.AppendLine($"  TITLE \"{c.Title}\"");
-                stringBuilder.AppendLine($"  INDEX 01 {(int)c.StartOffset.TotalMinutes}:{c.StartOffset:ss\\:ff}");
+                stringBuilder.AppendLine($"  INDEX 01 {(int)startTime.TotalMinutes}:{startTime:ss}:{(int)(startTime.Milliseconds / 1000d * 75)}");
             }
 
             return stringBuilder.ToString();

AaxDecrypter/DownloadLicense.cs

@@ -1,24 +0,0 @@
-using AAXClean;
-using Dinah.Core;
-
-namespace AaxDecrypter
-{
-    public class DownloadLicense
-    {
-        public string DownloadUrl { get; }
-        public string AudibleKey { get; }
-        public string AudibleIV { get; }
-        public string UserAgent { get; }
-        public ChapterInfo ChapterInfo { get; set; }
-
-        public DownloadLicense(string downloadUrl, string audibleKey, string audibleIV, string userAgent)
-        {
-            DownloadUrl = ArgumentValidator.EnsureNotNullOrEmpty(downloadUrl, nameof(downloadUrl));
-            UserAgent = ArgumentValidator.EnsureNotNullOrEmpty(userAgent, nameof(userAgent));
-
-            // no null/empty check. unencrypted files do not have these
-            AudibleKey = audibleKey;
-            AudibleIV = audibleIV;
-        }
-    }
-}

AaxDecrypter/DownloadOptions.cs

@@ -0,0 +1,30 @@
+using AAXClean;
+using Dinah.Core;
+
+namespace AaxDecrypter
+{
+    public class DownloadOptions
+    {
+        public string DownloadUrl { get; }
+        public string UserAgent { get; }
+        public string AudibleKey { get; init; }
+        public string AudibleIV { get; init; }
+        public OutputFormat OutputFormat { get; init; }
+        public bool TrimOutputToChapterLength { get; init; }
+        public bool RetainEncryptedFile { get; init; }
+        public bool StripUnabridged { get; init; }
+        public bool CreateCueSheet { get; init; }
+        public ChapterInfo ChapterInfo { get; set; }
+        public NAudio.Lame.LameConfig LameConfig { get; set; }
+        public bool Downsample { get; set; }
+        public bool MatchSourceBitrate { get; set; }       
+
+        public DownloadOptions(string downloadUrl, string userAgent)
+        {
+            DownloadUrl = ArgumentValidator.EnsureNotNullOrEmpty(downloadUrl, nameof(downloadUrl));
+            UserAgent = ArgumentValidator.EnsureNotNullOrEmpty(userAgent, nameof(userAgent));
+
+            // no null/empty check for key/iv. unencrypted files do not have them
+        }
+    }
+}

AaxDecrypter/UnencryptedAudiobookDownloader.cs

@@ -10,7 +10,7 @@ namespace AaxDecrypter
 	{
 		protected override StepSequence Steps { get; }
 
-		public UnencryptedAudiobookDownloader(string outFileName, string cacheDirectory, DownloadLicense dlLic)
+		public UnencryptedAudiobookDownloader(string outFileName, string cacheDirectory, DownloadOptions dlLic)
 			: base(outFileName, cacheDirectory, dlLic)
 		{
 			Steps = new StepSequence

AppScaffolding/AppScaffolding.csproj

@@ -3,7 +3,7 @@
 
   <PropertyGroup>
     <TargetFramework>net6.0-windows</TargetFramework>
-    <Version>7.1.1.1</Version>
+    <Version>7.2.0.1</Version>
   </PropertyGroup>
 
   <ItemGroup>

AppScaffolding/LibationScaffolding.cs

@@ -66,20 +66,53 @@ namespace AppScaffolding
 			if (!config.Exists(nameof(config.AllowLibationFixup)))
 				config.AllowLibationFixup = true;
 
+			if (!config.Exists(nameof(config.CreateCueSheet)))
+				config.CreateCueSheet = true;
+
+			if (!config.Exists(nameof(config.RetainAaxFile)))
+				config.RetainAaxFile = false;
+
+			if (!config.Exists(nameof(config.SplitFilesByChapter)))
+				config.SplitFilesByChapter = false;
+
+			if (!config.Exists(nameof(config.StripUnabridged)))
+				config.StripUnabridged = false;
+
+			if (!config.Exists(nameof(config.StripAudibleBrandAudio)))
+				config.StripAudibleBrandAudio = false;
+
 			if (!config.Exists(nameof(config.DecryptToLossy)))
 				config.DecryptToLossy = false;
 
+			if (!config.Exists(nameof(config.LameTargetBitrate)))
+				config.LameTargetBitrate = false;			
+			
+			if (!config.Exists(nameof(config.LameDownsampleMono)))
+				config.LameDownsampleMono = true;
+			
+			if (!config.Exists(nameof(config.LameBitrate)))
+				config.LameBitrate = 64;
+			
+			if (!config.Exists(nameof(config.LameConstantBitrate)))
+				config.LameConstantBitrate = false;
+			
+			if (!config.Exists(nameof(config.LameMatchSourceBR)))
+				config.LameMatchSourceBR = true;
+			
+			if (!config.Exists(nameof(config.LameVBRQuality)))
+				config.LameVBRQuality = 2;
+
 			if (!config.Exists(nameof(config.BadBook)))
 				config.BadBook = Configuration.BadBookAction.Ask;
 
-			if (!config.Exists(nameof(config.DownloadEpisodes)))
-				config.DownloadEpisodes = true;
+			if (!config.Exists(nameof(config.ShowImportedStats)))
+				config.ShowImportedStats = true;
 
 			if (!config.Exists(nameof(config.ImportEpisodes)))
 				config.ImportEpisodes = true;
 
-			if (!config.Exists(nameof(config.SplitFilesByChapter)))
-				config.SplitFilesByChapter = false;
+			if (!config.Exists(nameof(config.DownloadEpisodes)))
+				config.DownloadEpisodes = true;
 
 			if (!config.Exists(nameof(config.FolderTemplate)))
 				config.FolderTemplate = Templates.Folder.DefaultTemplate;
@@ -89,9 +122,6 @@ namespace AppScaffolding
 
 			if (!config.Exists(nameof(config.ChapterFileTemplate)))
 				config.ChapterFileTemplate = Templates.ChapterFile.DefaultTemplate;
-
-			if (!config.Exists(nameof(config.ShowImportedStats)))
-				config.ShowImportedStats = true;
 		}
 
 		/// <summary>Initialize logging. Run after migration</summary>

FileLiberator/AudioFileStorageExt.cs

@@ -39,7 +39,7 @@ namespace FileLiberator
         /// File name: final file name.
         /// </summary>
         public static string GetInProgressFilename(this AudioFileStorage _, LibraryBook libraryBook, string extension)
-            => Templates.File.GetFilename(libraryBook.ToDto(), AudibleFileStorage.DecryptInProgressDirectory, extension);
+            => Templates.File.GetFilename(libraryBook.ToDto(), AudibleFileStorage.DecryptInProgressDirectory, extension, returnFirstExisting: true);
 
         /// <summary>
         /// PDF: audio file does not exist

FileLiberator/DownloadDecryptBook.cs

@@ -61,7 +61,12 @@ namespace FileLiberator
 
                 // decrypt failed
                 if (!success)
+                {
+                    foreach (var tmpFile in entries.Where(f => f.FileType != FileType.AAXC))
+                        FileUtility.SaferDelete(tmpFile.Path);
+
                     return new StatusHandler { "Decrypt failed" };
+                }
 
                 // moves new files from temp dir to final dest
                 var movedAudioFile = moveFilesToBooksDir(libraryBook, entries);
@@ -86,37 +91,15 @@ namespace FileLiberator
 
             try
             {
+                var config = Configuration.Instance;
+
                 downloadValidation(libraryBook);
 
                 var api = await libraryBook.GetApiAsync();
                 var contentLic = await api.GetDownloadLicenseAsync(libraryBook.Book.AudibleProductId);
+                var audiobookDlLic = BuildDownloadOptions(config, contentLic);
 
-                var audiobookDlLic = new DownloadLicense
-                    (
-                    contentLic?.ContentMetadata?.ContentUrl?.OfflineUrl,
-                    contentLic?.Voucher?.Key,
-                    contentLic?.Voucher?.Iv,
-                    Resources.USER_AGENT
-                    );
-
-                //I assume if ContentFormat == "MPEG" that the delivered file is an unencrypted mp3.
-                //I also assume that if DrmType != Adrm, the file will be an mp3.
-                //These assumptions may be wrong, and only time and bug reports will tell.
-                var outputFormat = 
-                    contentLic.ContentMetadata.ContentReference.ContentFormat == "MPEG" ||
-                    (Configuration.Instance.AllowLibationFixup && Configuration.Instance.DecryptToLossy) ? 
-                    OutputFormat.Mp3 : OutputFormat.M4b;
-
-                if (Configuration.Instance.AllowLibationFixup || outputFormat == OutputFormat.Mp3)
-                {
-                    audiobookDlLic.ChapterInfo = new AAXClean.ChapterInfo();
-
-                    foreach (var chap in contentLic.ContentMetadata?.ChapterInfo?.Chapters)
-                        audiobookDlLic.ChapterInfo.AddChapter(chap.Title, TimeSpan.FromMilliseconds(chap.LengthMs));
-                }
-
-                var outFileName = AudibleFileStorage.Audio.GetInProgressFilename(libraryBook, outputFormat.ToString().ToLower());
-
+                var outFileName = AudibleFileStorage.Audio.GetInProgressFilename(libraryBook, audiobookDlLic.OutputFormat.ToString().ToLower());
                 var cacheDir = AudibleFileStorage.DownloadsInProgressDirectory;
 
                 if (contentLic.DrmType != AudibleApi.Common.DrmType.Adrm)
@@ -124,12 +107,12 @@ namespace FileLiberator
                 else
                 {
                     AaxcDownloadConvertBase converter
-                        = Configuration.Instance.SplitFilesByChapter ? new AaxcDownloadMultiConverter(
-                            outFileName, cacheDir, audiobookDlLic, outputFormat,
+                        = config.SplitFilesByChapter ? new AaxcDownloadMultiConverter(
+                            outFileName, cacheDir, audiobookDlLic,
                             AudibleFileStorage.Audio.CreateMultipartRenamerFunc(libraryBook))
-                        : new AaxcDownloadSingleConverter(outFileName, cacheDir, audiobookDlLic, outputFormat);
+                        : new AaxcDownloadSingleConverter(outFileName, cacheDir, audiobookDlLic);
 
-                    if (Configuration.Instance.AllowLibationFixup)
+                    if (config.AllowLibationFixup)
                         converter.RetrievedMetadata += (_, tags) => tags.Generes = string.Join(", ", libraryBook.Book.CategoriesNames);
 
                     abDownloader = converter;
@@ -137,7 +120,6 @@ namespace FileLiberator
 
                 abDownloader.DecryptProgressUpdate += OnStreamingProgressChanged;
                 abDownloader.DecryptTimeRemaining += OnStreamingTimeRemaining;
-
                 abDownloader.RetrievedTitle += OnTitleDiscovered;
                 abDownloader.RetrievedAuthors += OnAuthorsDiscovered;
                 abDownloader.RetrievedNarrators += OnNarratorsDiscovered;
@@ -154,6 +136,85 @@ namespace FileLiberator
             }
         }
 
+        private static DownloadOptions BuildDownloadOptions(Configuration config, AudibleApi.Common.ContentLicense contentLic)
+        {
+            //I assume if ContentFormat == "MPEG" that the delivered file is an unencrypted mp3.
+            //I also assume that if DrmType != Adrm, the file will be an mp3.
+            //These assumptions may be wrong, and only time and bug reports will tell.
+
+            bool encrypted = contentLic.DrmType == AudibleApi.Common.DrmType.Adrm;
+
+            var outputFormat = !encrypted || (config.AllowLibationFixup && config.DecryptToLossy) ?
+                     OutputFormat.Mp3 : OutputFormat.M4b;
+
+            var audiobookDlLic = new DownloadOptions
+                 (
+                 contentLic?.ContentMetadata?.ContentUrl?.OfflineUrl,
+                 Resources.USER_AGENT
+                 )
+            {
+                AudibleKey = contentLic?.Voucher?.Key,
+                AudibleIV = contentLic?.Voucher?.Iv,
+                OutputFormat = outputFormat,
+                TrimOutputToChapterLength = config.AllowLibationFixup && config.StripAudibleBrandAudio,
+                RetainEncryptedFile = config.RetainAaxFile && encrypted,
+                StripUnabridged = config.AllowLibationFixup && config.StripUnabridged,
+                Downsample = config.AllowLibationFixup && config.LameDownsampleMono,
+                MatchSourceBitrate = config.AllowLibationFixup && config.LameMatchSourceBR && config.LameTargetBitrate,
+                CreateCueSheet = config.CreateCueSheet
+            };
+
+            if (config.AllowLibationFixup || outputFormat == OutputFormat.Mp3)
+            {
+
+                long startMs = audiobookDlLic.TrimOutputToChapterLength ?
+                    contentLic.ContentMetadata.ChapterInfo.BrandIntroDurationMs : 0;
+
+                audiobookDlLic.ChapterInfo = new AAXClean.ChapterInfo(TimeSpan.FromMilliseconds(startMs));
+
+                for (int i = 0; i < contentLic.ContentMetadata.ChapterInfo.Chapters.Length; i++)
+                {
+                    var chapter = contentLic.ContentMetadata.ChapterInfo.Chapters[i];
+                    long chapLenMs = chapter.LengthMs;
+
+                    if (i == 0)
+                        chapLenMs -= startMs;
+
+                    if (config.StripAudibleBrandAudio && i == contentLic.ContentMetadata.ChapterInfo.Chapters.Length - 1)
+                        chapLenMs -= contentLic.ContentMetadata.ChapterInfo.BrandOutroDurationMs;
+
+                    audiobookDlLic.ChapterInfo.AddChapter(chapter.Title, TimeSpan.FromMilliseconds(chapLenMs));
+                }
+            }
+
+            NAudio.Lame.LameConfig lameConfig = new();
+
+
+            lameConfig.Mode = NAudio.Lame.MPEGMode.Mono;
+
+            if (config.LameTargetBitrate)
+			{
+                if (config.LameConstantBitrate)
+                    lameConfig.BitRate = config.LameBitrate;
+                else
+                {
+                    lameConfig.ABRRateKbps = config.LameBitrate;
+                    lameConfig.VBR = NAudio.Lame.VBRMode.ABR;
+                    lameConfig.WriteVBRTag = true;
+                }
+			}
+			else
+			{
+                lameConfig.VBR = NAudio.Lame.VBRMode.Default;
+                lameConfig.VBRQuality = config.LameVBRQuality;
+                lameConfig.WriteVBRTag = true;
+            }
+
+            audiobookDlLic.LameConfig = lameConfig;
+
+            return audiobookDlLic;
+        }
+
         private static void downloadValidation(LibraryBook libraryBook)
         {
             string errorString(string field)

FileManager/FileNamingTemplate.cs

@@ -29,14 +29,14 @@ namespace FileManager
         public string IllegalCharacterReplacements { get; set; }
 
         /// <summary>Generate a valid path for this file or directory</summary>
-        public string GetFilePath()
+        public string GetFilePath(bool returnFirstExisting = false)
         {
             var filename = Template;
 
             foreach (var r in ParameterReplacements)
                 filename = filename.Replace($"<{formatKey(r.Key)}>", formatValue(r.Value));
 
-            return FileUtility.GetValidFilename(filename, IllegalCharacterReplacements);
+            return FileUtility.GetValidFilename(filename, IllegalCharacterReplacements, returnFirstExisting);
         }
 
         private static string formatKey(string key)

FileManager/FileUtility.cs

@@ -48,7 +48,7 @@ namespace FileManager
         /// <br/>- ensure uniqueness
         /// <br/>- enforce max file length
         /// </summary>
-        public static string GetValidFilename(string path, string illegalCharacterReplacements = "")
+        public static string GetValidFilename(string path, string illegalCharacterReplacements = "", bool returnFirstExisting = false)
         {
             ArgumentValidator.EnsureNotNull(path, nameof(path));
 
@@ -69,7 +69,7 @@ namespace FileManager
             fullfilename = removeInvalidWhitespace(fullfilename);
 
             var i = 0;
-            while (File.Exists(fullfilename))
+            while (File.Exists(fullfilename) && !returnFirstExisting)
             {
                 var increm = $" ({++i})";
                 fullfilename = fileStem.Truncate(MAX_FILENAME_LENGTH - increm.Length - extension.Length) + increm + extension;

LibationFileManager/Configuration.cs

@@ -96,18 +96,88 @@ namespace LibationFileManager
             set => persistentDictionary.SetNonString(nameof(AllowLibationFixup), value);
         }
 
+        [Description("Create a cue sheet (.cue)")]
+        public bool CreateCueSheet
+        {
+            get => persistentDictionary.GetNonString<bool>(nameof(CreateCueSheet));
+            set => persistentDictionary.SetNonString(nameof(CreateCueSheet), value);
+        }
+
+        [Description("Retain the Aax file after successfully decrypting")]
+        public bool RetainAaxFile
+        {
+            get => persistentDictionary.GetNonString<bool>(nameof(RetainAaxFile));
+            set => persistentDictionary.SetNonString(nameof(RetainAaxFile), value);
+        }
+
+        [Description("Split my books into multiple files by chapter")]
+        public bool SplitFilesByChapter
+        {
+            get => persistentDictionary.GetNonString<bool>(nameof(SplitFilesByChapter));
+            set => persistentDictionary.SetNonString(nameof(SplitFilesByChapter), value);
+        }
+
+        [Description("Strip \"(Unabridged)\" from audiobook metadata tags")]
+        public bool StripUnabridged
+        {
+            get => persistentDictionary.GetNonString<bool>(nameof(StripUnabridged));
+            set => persistentDictionary.SetNonString(nameof(StripUnabridged), value);
+        }
+
+        [Description("Allow Libation to remove audible branding from the start\r\nand end of audiobooks. (e.g. \"This is Audible\")")]
+        public bool StripAudibleBrandAudio
+        {
+            get => persistentDictionary.GetNonString<bool>(nameof(StripAudibleBrandAudio));
+            set => persistentDictionary.SetNonString(nameof(StripAudibleBrandAudio), value);
+        }
+
         [Description("Decrypt to lossy format?")]
         public bool DecryptToLossy
         {
             get => persistentDictionary.GetNonString<bool>(nameof(DecryptToLossy));
             set => persistentDictionary.SetNonString(nameof(DecryptToLossy), value);
         }
-        
-        [Description("Split my books into multiple files by chapter")]
-        public bool SplitFilesByChapter
+
+        [Description("Lame encoder target. true = Bitrate, false = Quality")]
+        public bool LameTargetBitrate
         {
-            get => persistentDictionary.GetNonString<bool>(nameof(SplitFilesByChapter));
-            set => persistentDictionary.SetNonString(nameof(SplitFilesByChapter), value);
+            get => persistentDictionary.GetNonString<bool>(nameof(LameTargetBitrate));
+            set => persistentDictionary.SetNonString(nameof(LameTargetBitrate), value);
+        }
+
+        [Description("Lame encoder downsamples to mono")]
+        public bool LameDownsampleMono
+        {
+            get => persistentDictionary.GetNonString<bool>(nameof(LameDownsampleMono));
+            set => persistentDictionary.SetNonString(nameof(LameDownsampleMono), value);
+        }
+
+        [Description("Lame target bitrate [16,320]")]
+        public int LameBitrate
+        {
+            get => persistentDictionary.GetNonString<int>(nameof(LameBitrate));
+            set => persistentDictionary.SetNonString(nameof(LameBitrate), value);
+        }
+
+        [Description("Restrict encoder to constant bitrate?")]
+        public bool LameConstantBitrate
+        {
+            get => persistentDictionary.GetNonString<bool>(nameof(LameConstantBitrate));
+            set => persistentDictionary.SetNonString(nameof(LameConstantBitrate), value);
+        }
+
+        [Description("Match the source bitrate?")]
+        public bool LameMatchSourceBR
+        {
+            get => persistentDictionary.GetNonString<bool>(nameof(LameMatchSourceBR));
+            set => persistentDictionary.SetNonString(nameof(LameMatchSourceBR), value);
+        }
+
+        [Description("Lame target VBR quality [10,100]")]
+        public int LameVBRQuality
+        {
+            get => persistentDictionary.GetNonString<int>(nameof(LameVBRQuality));
+            set => persistentDictionary.SetNonString(nameof(LameVBRQuality), value);
         }
 
         public enum BadBookAction

LibationFileManager/Templates.cs

@@ -230,9 +230,9 @@ namespace LibationFileManager
 
             #region to file name
             /// <summary>USES LIVE CONFIGURATION VALUES</summary>
-            public string GetFilename(LibraryBookDto libraryBookDto, string dirFullPath, string extension)
+            public string GetFilename(LibraryBookDto libraryBookDto, string dirFullPath, string extension, bool returnFirstExisting = false)
                 => getFileNamingTemplate(libraryBookDto, Configuration.Instance.FileTemplate, dirFullPath, extension)
-                .GetFilePath();
+                .GetFilePath(returnFirstExisting);
             #endregion
         }
 

LibationWinForms/Dialogs/SettingsDialog.AudioSettings.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace LibationWinForms.Dialogs
+{
+	partial class SettingsDialog
+	{
+		private void lameTargetRb_CheckedChanged(object sender, EventArgs e)
+		{
+			lameBitrateGb.Enabled = lameTargetBitrateRb.Checked;
+			lameQualityGb.Enabled = !lameTargetBitrateRb.Checked;
+		}
+
+		private void LameMatchSourceBRCbox_CheckedChanged(object sender, EventArgs e)
+		{
+			lameBitrateTb.Enabled = !LameMatchSourceBRCbox.Checked;
+			lameConstantBitrateCbox.Enabled = !LameMatchSourceBRCbox.Checked;
+		}
+
+		private void convertFormatRb_CheckedChanged(object sender, EventArgs e)
+		{
+			lameOptionsGb.Enabled = convertLossyRb.Checked;
+			lameTargetRb_CheckedChanged(sender, e);
+			LameMatchSourceBRCbox_CheckedChanged(sender, e);
+		}
+		private void allowLibationFixupCbox_CheckedChanged(object sender, EventArgs e)
+		{
+			convertLosslessRb.Enabled = allowLibationFixupCbox.Checked;
+			convertLossyRb.Enabled = allowLibationFixupCbox.Checked;
+			splitFilesByChapterCbox.Enabled = allowLibationFixupCbox.Checked;
+			stripUnabridgedCbox.Enabled = allowLibationFixupCbox.Checked;
+			stripAudibleBrandingCbox.Enabled = allowLibationFixupCbox.Checked;
+
+			if (!allowLibationFixupCbox.Checked)
+			{
+				convertLosslessRb.Checked = true;
+				splitFilesByChapterCbox.Checked = false;
+				stripUnabridgedCbox.Checked = false;
+				stripAudibleBrandingCbox.Checked = false;
+			}
+		}
+	}
+}

LibationWinForms/Dialogs/SettingsDialog.cs

@@ -34,6 +34,10 @@ namespace LibationWinForms.Dialogs
 			this.inProgressDescLbl.Text = desc(nameof(config.InProgress));
 			this.allowLibationFixupCbox.Text = desc(nameof(config.AllowLibationFixup));
 			this.splitFilesByChapterCbox.Text = desc(nameof(config.SplitFilesByChapter));
+			this.stripAudibleBrandingCbox.Text = desc(nameof(config.StripAudibleBrandAudio));
+			this.retainAaxFileCbox.Text = desc(nameof(config.RetainAaxFile));
+			this.stripUnabridgedCbox.Text = desc(nameof(config.StripUnabridged));
+			this.createCueSheetCbox.Text = desc(nameof(config.CreateCueSheet));
 
 			booksSelectControl.SetSearchTitle("books location");
 			booksSelectControl.SetDirectoryItems(
@@ -47,14 +51,30 @@ namespace LibationWinForms.Dialogs
 				"Books");
 			booksSelectControl.SelectDirectory(config.Books);
 
+			allowLibationFixupCbox.Checked = config.AllowLibationFixup;
+			createCueSheetCbox.Checked = config.CreateCueSheet;
+			retainAaxFileCbox.Checked = config.RetainAaxFile;
+			splitFilesByChapterCbox.Checked = config.SplitFilesByChapter;
+			stripUnabridgedCbox.Checked = config.StripUnabridged;
+			stripAudibleBrandingCbox.Checked = config.StripAudibleBrandAudio;
+			convertLosslessRb.Checked = !config.DecryptToLossy;
+			convertLossyRb.Checked = config.DecryptToLossy;
+
+			lameTargetBitrateRb.Checked = config.LameTargetBitrate;
+			lameTargetQualityRb.Checked = !config.LameTargetBitrate;
+			lameDownsampleMonoCbox.Checked = config.LameDownsampleMono;
+			lameBitrateTb.Value = config.LameBitrate;
+			lameConstantBitrateCbox.Checked = config.LameConstantBitrate;
+			LameMatchSourceBRCbox.Checked = config.LameMatchSourceBR;
+			lameVBRQualityTb.Value = config.LameVBRQuality;
+
 			showImportedStatsCb.Checked = config.ShowImportedStats;
 			importEpisodesCb.Checked = config.ImportEpisodes;
 			downloadEpisodesCb.Checked = config.DownloadEpisodes;
-			allowLibationFixupCbox.Checked = config.AllowLibationFixup;
-			convertLosslessRb.Checked = !config.DecryptToLossy;
-			convertLossyRb.Checked = config.DecryptToLossy;
-			splitFilesByChapterCbox.Checked = config.SplitFilesByChapter;
 
+			lameTargetRb_CheckedChanged(this, e);
+			LameMatchSourceBRCbox_CheckedChanged(this, e);
+			convertFormatRb_CheckedChanged(this, e);
 			allowLibationFixupCbox_CheckedChanged(this, e);
 
 			inProgressSelectControl.SetDirectoryItems(new()
@@ -90,19 +110,6 @@ namespace LibationWinForms.Dialogs
 			chapterFileTemplateTb.Text = config.ChapterFileTemplate;
 		}
 
-		private void allowLibationFixupCbox_CheckedChanged(object sender, EventArgs e)
-		{
-			convertLosslessRb.Enabled = allowLibationFixupCbox.Checked;
-			convertLossyRb.Enabled = allowLibationFixupCbox.Checked;
-			splitFilesByChapterCbox.Enabled = allowLibationFixupCbox.Checked;
-
-			if (!allowLibationFixupCbox.Checked)
-			{
-				convertLosslessRb.Checked = true;
-				splitFilesByChapterCbox.Checked = false;
-			}
-		}
-
 		private void logsBtn_Click(object sender, EventArgs e) => Go.To.Folder(Configuration.Instance.LibationFiles);
 
 		private void folderTemplateBtn_Click(object sender, EventArgs e) => editTemplate(Templates.Folder, folderTemplateTb);
@@ -168,12 +175,24 @@ namespace LibationWinForms.Dialogs
 					MessageBoxVerboseLoggingWarning.ShowIfTrue();
 			}
 
+			config.AllowLibationFixup = allowLibationFixupCbox.Checked;
+			config.CreateCueSheet = createCueSheetCbox.Checked;
+			config.RetainAaxFile = retainAaxFileCbox.Checked;
+			config.SplitFilesByChapter = splitFilesByChapterCbox.Checked;
+			config.StripUnabridged = stripUnabridgedCbox.Checked;
+			config.StripAudibleBrandAudio = stripAudibleBrandingCbox.Checked;
+			config.DecryptToLossy = convertLossyRb.Checked;
+
+			config.LameTargetBitrate = lameTargetBitrateRb.Checked;
+			config.LameDownsampleMono = lameDownsampleMonoCbox.Checked;
+			config.LameBitrate = lameBitrateTb.Value;
+			config.LameConstantBitrate = lameConstantBitrateCbox.Checked;
+			config.LameMatchSourceBR = LameMatchSourceBRCbox.Checked;
+			config.LameVBRQuality = lameVBRQualityTb.Value;
+
 			config.ShowImportedStats = showImportedStatsCb.Checked;
 			config.ImportEpisodes = importEpisodesCb.Checked;
 			config.DownloadEpisodes = downloadEpisodesCb.Checked;
-			config.AllowLibationFixup = allowLibationFixupCbox.Checked;
-			config.DecryptToLossy = convertLossyRb.Checked;
-			config.SplitFilesByChapter = splitFilesByChapterCbox.Checked;
 
 			config.InProgress = inProgressSelectControl.SelectedDirectory;
 
@@ -197,5 +216,6 @@ namespace LibationWinForms.Dialogs
 			this.DialogResult = DialogResult.Cancel;
 			this.Close();
 		}
+
 	}
 }

LibationWinForms/grid/GridEntry.cs

@@ -10,6 +10,7 @@ using Dinah.Core.DataBinding;
 using Dinah.Core;
 using Dinah.Core.Drawing;
 using LibationFileManager;
+using System.Threading.Tasks;
 
 namespace LibationWinForms
 {
@@ -39,6 +40,7 @@ namespace LibationWinForms
 			}
 		}
 
+		public bool DownloadInProgress { get; private set; }
 		public string ProductRating { get; private set; }
 		public string PurchaseDate { get; private set; }
 		public string MyRating { get; private set; }
@@ -77,6 +79,22 @@ namespace LibationWinForms
 
 		public GridEntry(LibraryBook libraryBook) => setLibraryBook(libraryBook);
 
+		public async Task DownloadBook()
+		{
+			if (!DownloadInProgress)
+			{
+				try
+				{
+					DownloadInProgress = true;
+					await BookLiberation.ProcessorAutomationController.BackupSingleBookAsync(LibraryBook);
+				}
+				finally
+				{
+					DownloadInProgress = false;
+				}
+			}
+		}
+
 		public void UpdateLibraryBook(LibraryBook libraryBook)
 		{
 			if (AudibleProductId != libraryBook.Book.AudibleProductId)

LibationWinForms/grid/ProductsGrid.cs

@@ -89,7 +89,7 @@ namespace LibationWinForms
 			}
 
 			// else: liberate
-			await BookLiberation.ProcessorAutomationController.BackupSingleBookAsync(libraryBook);
+			await liveGridEntry.DownloadBook();
 		}
 
 		private static void Details_Click(GridEntry liveGridEntry)