307 lines
10 KiB
C#
307 lines
10 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using AaxDecrypter;
|
|
using ApplicationServices;
|
|
using AudibleApi;
|
|
using DataLayer;
|
|
using Dinah.Core;
|
|
using Dinah.Core.ErrorHandling;
|
|
using FileManager;
|
|
using LibationFileManager;
|
|
|
|
namespace FileLiberator
|
|
{
|
|
public class DownloadDecryptBook : AudioDecodable
|
|
{
|
|
public override string Name => "Download & Decrypt";
|
|
private AudiobookDownloadBase abDownloader;
|
|
|
|
public override bool Validate(LibraryBook libraryBook) => !libraryBook.Book.Audio_Exists();
|
|
|
|
public override Task CancelAsync() => abDownloader?.CancelAsync() ?? Task.CompletedTask;
|
|
|
|
public override async Task<StatusHandler> ProcessAsync(LibraryBook libraryBook)
|
|
{
|
|
var entries = new List<FilePathCache.CacheEntry>();
|
|
// these only work so minimally b/c CacheEntry is a record.
|
|
// in case of parallel decrypts, only capture the ones for this book id.
|
|
// if user somehow starts multiple decrypts of the same book in parallel: on their own head be it
|
|
void FilePathCache_Inserted(object sender, FilePathCache.CacheEntry e)
|
|
{
|
|
if (e.Id.EqualsInsensitive(libraryBook.Book.AudibleProductId))
|
|
entries.Add(e);
|
|
}
|
|
void FilePathCache_Removed(object sender, FilePathCache.CacheEntry e)
|
|
{
|
|
if (e.Id.EqualsInsensitive(libraryBook.Book.AudibleProductId))
|
|
entries.Remove(e);
|
|
}
|
|
|
|
OnBegin(libraryBook);
|
|
|
|
try
|
|
{
|
|
if (libraryBook.Book.Audio_Exists())
|
|
return new StatusHandler { "Cannot find decrypt. Final audio file already exists" };
|
|
|
|
bool success = false;
|
|
try
|
|
{
|
|
FilePathCache.Inserted += FilePathCache_Inserted;
|
|
FilePathCache.Removed += FilePathCache_Removed;
|
|
|
|
success = await downloadAudiobookAsync(libraryBook);
|
|
}
|
|
finally
|
|
{
|
|
FilePathCache.Inserted -= FilePathCache_Inserted;
|
|
FilePathCache.Removed -= FilePathCache_Removed;
|
|
}
|
|
|
|
// decrypt failed
|
|
if (!success)
|
|
{
|
|
foreach (var tmpFile in entries.Where(f => f.FileType != FileType.AAXC))
|
|
FileUtility.SaferDelete(tmpFile.Path);
|
|
|
|
return abDownloader?.IsCanceled == true ?
|
|
new StatusHandler { "Cancelled" } :
|
|
new StatusHandler { "Decrypt failed" };
|
|
}
|
|
|
|
// moves new files from temp dir to final dest.
|
|
// This could take a few seconds if moving hundreds of files.
|
|
var movedAudioFile = await Task.Run(() => moveFilesToBooksDir(libraryBook, entries));
|
|
|
|
// decrypt failed
|
|
if (!movedAudioFile)
|
|
return new StatusHandler { "Cannot find final audio file after decryption" };
|
|
|
|
if (Configuration.Instance.DownloadCoverArt)
|
|
DownloadCoverArt(libraryBook);
|
|
|
|
libraryBook.Book.UpdateBookStatus(LiberatedStatus.Liberated);
|
|
|
|
return new StatusHandler();
|
|
}
|
|
finally
|
|
{
|
|
OnCompleted(libraryBook);
|
|
}
|
|
}
|
|
|
|
private async Task<bool> downloadAudiobookAsync(LibraryBook libraryBook)
|
|
{
|
|
var config = Configuration.Instance;
|
|
|
|
downloadValidation(libraryBook);
|
|
|
|
var api = await libraryBook.GetApiAsync();
|
|
var contentLic = await api.GetDownloadLicenseAsync(libraryBook.Book.AudibleProductId);
|
|
var dlOptions = BuildDownloadOptions(libraryBook, config, contentLic);
|
|
|
|
var outFileName = AudibleFileStorage.Audio.GetInProgressFilename(libraryBook, dlOptions.OutputFormat.ToString().ToLower());
|
|
var cacheDir = AudibleFileStorage.DownloadsInProgressDirectory;
|
|
|
|
if (contentLic.DrmType != AudibleApi.Common.DrmType.Adrm)
|
|
abDownloader = new UnencryptedAudiobookDownloader(outFileName, cacheDir, dlOptions);
|
|
else
|
|
{
|
|
AaxcDownloadConvertBase converter
|
|
= config.SplitFilesByChapter ?
|
|
new AaxcDownloadMultiConverter(outFileName, cacheDir, dlOptions) :
|
|
new AaxcDownloadSingleConverter(outFileName, cacheDir, dlOptions);
|
|
|
|
if (config.AllowLibationFixup)
|
|
converter.RetrievedMetadata += (_, tags) => tags.Generes = string.Join(", ", libraryBook.Book.CategoriesNames());
|
|
|
|
abDownloader = converter;
|
|
}
|
|
|
|
abDownloader.DecryptProgressUpdate += OnStreamingProgressChanged;
|
|
abDownloader.DecryptTimeRemaining += OnStreamingTimeRemaining;
|
|
abDownloader.RetrievedTitle += OnTitleDiscovered;
|
|
abDownloader.RetrievedAuthors += OnAuthorsDiscovered;
|
|
abDownloader.RetrievedNarrators += OnNarratorsDiscovered;
|
|
abDownloader.RetrievedCoverArt += AaxcDownloader_RetrievedCoverArt;
|
|
abDownloader.FileCreated += (_, path) => OnFileCreated(libraryBook, path);
|
|
|
|
// REAL WORK DONE HERE
|
|
var success = await Task.Run(abDownloader.Run);
|
|
|
|
return success;
|
|
}
|
|
|
|
private DownloadOptions BuildDownloadOptions(LibraryBook libraryBook, 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 dlOptions = new DownloadOptions
|
|
(
|
|
libraryBook,
|
|
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,
|
|
LameConfig = GetLameOptions(config)
|
|
};
|
|
|
|
var chapters = getChapters(contentLic.ContentMetadata.ChapterInfo.Chapters).OrderBy(c => c.StartOffsetMs).ToList();
|
|
|
|
if (config.AllowLibationFixup || outputFormat == OutputFormat.Mp3)
|
|
{
|
|
long startMs = dlOptions.TrimOutputToChapterLength ?
|
|
contentLic.ContentMetadata.ChapterInfo.BrandIntroDurationMs : 0;
|
|
|
|
dlOptions.ChapterInfo = new AAXClean.ChapterInfo(TimeSpan.FromMilliseconds(startMs));
|
|
|
|
for (int i = 0; i < chapters.Count; i++)
|
|
{
|
|
var chapter = chapters[i];
|
|
long chapLenMs = chapter.LengthMs;
|
|
|
|
if (i == 0)
|
|
chapLenMs -= startMs;
|
|
|
|
if (config.StripAudibleBrandAudio && i == chapters.Count - 1)
|
|
chapLenMs -= contentLic.ContentMetadata.ChapterInfo.BrandOutroDurationMs;
|
|
|
|
dlOptions.ChapterInfo.AddChapter(chapter.Title, TimeSpan.FromMilliseconds(chapLenMs));
|
|
}
|
|
}
|
|
|
|
return dlOptions;
|
|
}
|
|
|
|
private List<AudibleApi.Common.Chapter> getChapters(IEnumerable<AudibleApi.Common.Chapter> chapters)
|
|
{
|
|
List<AudibleApi.Common.Chapter> chaps = chapters.ToList();
|
|
|
|
foreach (var c in chapters)
|
|
{
|
|
if (c.Chapters is not null)
|
|
{
|
|
var children = getChapters(c.Chapters);
|
|
|
|
foreach (var child in children)
|
|
child.Title = string.IsNullOrEmpty(c.Title) ? child.Title : $"{c.Title}: {child.Title}";
|
|
|
|
chaps.AddRange(children);
|
|
}
|
|
}
|
|
return chaps;
|
|
}
|
|
|
|
private static void downloadValidation(LibraryBook libraryBook)
|
|
{
|
|
string errorString(string field)
|
|
=> $"{errorTitle()}\r\nCannot download book. {field} is not known. Try re-importing the account which owns this book.";
|
|
|
|
string errorTitle()
|
|
{
|
|
var title
|
|
= (libraryBook.Book.Title.Length > 53)
|
|
? $"{libraryBook.Book.Title.Truncate(50)}..."
|
|
: libraryBook.Book.Title;
|
|
var errorBookTitle = $"{title} [{libraryBook.Book.AudibleProductId}]";
|
|
return errorBookTitle;
|
|
};
|
|
|
|
if (string.IsNullOrWhiteSpace(libraryBook.Account))
|
|
throw new Exception(errorString("Account"));
|
|
|
|
if (string.IsNullOrWhiteSpace(libraryBook.Book.Locale))
|
|
throw new Exception(errorString("Locale"));
|
|
}
|
|
|
|
private void AaxcDownloader_RetrievedCoverArt(object _, byte[] e)
|
|
{
|
|
if (e is not null)
|
|
OnCoverImageDiscovered(e);
|
|
else if (Configuration.Instance.AllowLibationFixup)
|
|
abDownloader.SetCoverArt(OnRequestCoverArt());
|
|
}
|
|
|
|
/// <summary>Move new files to 'Books' directory</summary>
|
|
/// <returns>True if audiobook file(s) were successfully created and can be located on disk. Else false.</returns>
|
|
private static bool moveFilesToBooksDir(LibraryBook libraryBook, List<FilePathCache.CacheEntry> entries)
|
|
{
|
|
// create final directory. move each file into it
|
|
var destinationDir = AudibleFileStorage.Audio.GetDestinationDirectory(libraryBook);
|
|
Directory.CreateDirectory(destinationDir);
|
|
|
|
FilePathCache.CacheEntry getFirstAudio() => entries.FirstOrDefault(f => f.FileType == FileType.Audio);
|
|
|
|
if (getFirstAudio() == default)
|
|
return false;
|
|
|
|
for (var i = 0; i < entries.Count; i++)
|
|
{
|
|
var entry = entries[i];
|
|
|
|
var realDest = FileUtility.SaferMoveToValidPath(entry.Path, Path.Combine(destinationDir, Path.GetFileName(entry.Path)), Configuration.Instance.ReplacementCharacters);
|
|
FilePathCache.Insert(libraryBook.Book.AudibleProductId, realDest);
|
|
|
|
// propagate corrected path. Must update cache with corrected path. Also want updated path for cue file (after this for-loop)
|
|
entries[i] = entry with { Path = realDest };
|
|
}
|
|
|
|
var cue = entries.FirstOrDefault(f => f.FileType == FileType.Cue);
|
|
if (cue != default)
|
|
Cue.UpdateFileName(cue.Path, getFirstAudio().Path);
|
|
|
|
AudibleFileStorage.Audio.Refresh();
|
|
|
|
return true;
|
|
}
|
|
|
|
private void DownloadCoverArt(LibraryBook libraryBook)
|
|
{
|
|
var destinationDir = AudibleFileStorage.Audio.GetDestinationDirectory(libraryBook);
|
|
var coverPath = AudibleFileStorage.Audio.GetBooksDirectoryFilename(libraryBook, ".jpg");
|
|
coverPath = Path.Combine(destinationDir, Path.GetFileName(coverPath));
|
|
|
|
try
|
|
{
|
|
if (File.Exists(coverPath))
|
|
FileUtility.SaferDelete(coverPath);
|
|
|
|
(string picId, PictureSize size) = libraryBook.Book.PictureLarge is null ?
|
|
(libraryBook.Book.PictureId, PictureSize.Native) :
|
|
(libraryBook.Book.PictureLarge, PictureSize.Native);
|
|
|
|
var picBytes = PictureStorage.GetPictureSynchronously(new PictureDefinition(picId, size));
|
|
|
|
if (picBytes.Length > 0)
|
|
File.WriteAllBytes(coverPath, picBytes);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
//Failure to download cover art should not be
|
|
//considered a failure to download the book
|
|
Serilog.Log.Logger.Error(ex, $"Error downloading cover art of {libraryBook.Book.AudibleProductId} to {coverPath} catalog product.");
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|