347 lines
12 KiB
C#
347 lines
12 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using Dinah.Core;
|
|
using Dinah.Core.Diagnostics;
|
|
using Dinah.Core.IO;
|
|
using Dinah.Core.StepRunner;
|
|
|
|
namespace AaxDecrypter
|
|
{
|
|
public interface ISimpleAaxToM4bConverter
|
|
{
|
|
event EventHandler<int> DecryptProgressUpdate;
|
|
|
|
bool Run();
|
|
|
|
string AppName { get; set; }
|
|
string inputFileName { get; }
|
|
byte[] coverBytes { get; }
|
|
string outDir { get; }
|
|
string outputFileName { get; }
|
|
|
|
Chapters chapters { get; }
|
|
Tags tags { get; }
|
|
EncodingInfo encodingInfo { get; }
|
|
|
|
void SetOutputFilename(string outFileName);
|
|
}
|
|
public interface IAdvancedAaxToM4bConverter : ISimpleAaxToM4bConverter
|
|
{
|
|
bool Step1_CreateDir();
|
|
bool Step2_DecryptAax();
|
|
bool Step3_Chapterize();
|
|
bool Step4_InsertCoverArt();
|
|
bool Step5_Cleanup();
|
|
bool Step6_AddTags();
|
|
bool End_CreateCue();
|
|
bool End_CreateNfo();
|
|
}
|
|
/// <summary>full c# app. integrated logging. no UI</summary>
|
|
public class AaxToM4bConverter : IAdvancedAaxToM4bConverter
|
|
{
|
|
public event EventHandler<int> DecryptProgressUpdate;
|
|
|
|
public string inputFileName { get; }
|
|
public string decryptKey { get; private set; }
|
|
|
|
private StepSequence steps { get; }
|
|
public byte[] coverBytes { get; private set; }
|
|
|
|
public string AppName { get; set; } = nameof(AaxToM4bConverter);
|
|
|
|
public string outDir { get; private set; }
|
|
public string outputFileName { get; private set; }
|
|
|
|
public Chapters chapters { get; private set; }
|
|
public Tags tags { get; private set; }
|
|
public EncodingInfo encodingInfo { get; private set; }
|
|
|
|
public static async Task<AaxToM4bConverter> CreateAsync(string inputFile, string decryptKey)
|
|
{
|
|
var converter = new AaxToM4bConverter(inputFile, decryptKey);
|
|
await converter.prelimProcessing();
|
|
converter.printPrelim();
|
|
|
|
return converter;
|
|
}
|
|
private AaxToM4bConverter(string inputFile, string decryptKey)
|
|
{
|
|
ArgumentValidator.EnsureNotNullOrWhiteSpace(inputFile, nameof(inputFile));
|
|
if (!File.Exists(inputFile))
|
|
throw new ArgumentNullException(nameof(inputFile), "File does not exist");
|
|
|
|
steps = new StepSequence
|
|
{
|
|
Name = "Convert Aax To M4b",
|
|
|
|
["Step 1: Create Dir"] = Step1_CreateDir,
|
|
["Step 2: Decrypt Aax"] = Step2_DecryptAax,
|
|
["Step 3: Chapterize and tag"] = Step3_Chapterize,
|
|
["Step 4: Insert Cover Art"] = Step4_InsertCoverArt,
|
|
["Step 5: Cleanup"] = Step5_Cleanup,
|
|
["Step 6: Add Tags"] = Step6_AddTags,
|
|
["End: Create Cue"] = End_CreateCue,
|
|
["End: Create Nfo"] = End_CreateNfo
|
|
};
|
|
|
|
inputFileName = inputFile;
|
|
this.decryptKey = decryptKey;
|
|
}
|
|
|
|
private async Task prelimProcessing()
|
|
{
|
|
tags = new Tags(inputFileName);
|
|
encodingInfo = new EncodingInfo(inputFileName);
|
|
chapters = new Chapters(inputFileName, tags.duration.TotalSeconds);
|
|
|
|
var defaultFilename = Path.Combine(
|
|
Path.GetDirectoryName(inputFileName),
|
|
PathLib.ToPathSafeString(tags.author),
|
|
PathLib.ToPathSafeString(tags.title) + ".m4b"
|
|
);
|
|
|
|
// set default name
|
|
SetOutputFilename(defaultFilename);
|
|
|
|
await Task.Run(() => saveCover(inputFileName));
|
|
}
|
|
|
|
private void saveCover(string aaxFile)
|
|
{
|
|
using var file = TagLib.File.Create(aaxFile, "audio/mp4", TagLib.ReadStyle.Average);
|
|
coverBytes = file.Tag.Pictures[0].Data.Data;
|
|
}
|
|
|
|
private void printPrelim()
|
|
{
|
|
Console.WriteLine($"Audible Book ID = {tags.id}");
|
|
|
|
Console.WriteLine($"Book: {tags.title}");
|
|
Console.WriteLine($"Author: {tags.author}");
|
|
Console.WriteLine($"Narrator: {tags.narrator}");
|
|
Console.WriteLine($"Year: {tags.year}");
|
|
Console.WriteLine($"Total Time: {tags.duration.GetTotalTimeFormatted()} in {chapters.Count} chapters");
|
|
Console.WriteLine($"WARNING-Source is {encodingInfo.originalBitrate} kbits @ {encodingInfo.sampleRate}Hz, {encodingInfo.channels} channels");
|
|
}
|
|
|
|
public bool Run()
|
|
{
|
|
var (IsSuccess, Elapsed) = steps.Run();
|
|
|
|
if (!IsSuccess)
|
|
{
|
|
Console.WriteLine("WARNING-Conversion failed");
|
|
return false;
|
|
}
|
|
|
|
var speedup = (int)(tags.duration.TotalSeconds / (long)Elapsed.TotalSeconds);
|
|
Console.WriteLine("Speedup is " + speedup + "x realtime.");
|
|
Console.WriteLine("Done");
|
|
return true;
|
|
}
|
|
|
|
public void SetOutputFilename(string outFileName)
|
|
{
|
|
outputFileName = PathLib.ReplaceExtension(outFileName, ".m4b");
|
|
outDir = Path.GetDirectoryName(outputFileName);
|
|
|
|
if (File.Exists(outputFileName))
|
|
File.Delete(outputFileName);
|
|
}
|
|
|
|
private string outputFileWithNewExt(string extension) => PathLib.ReplaceExtension(outputFileName, extension);
|
|
|
|
public bool Step1_CreateDir()
|
|
{
|
|
ProcessRunner.WorkingDir = outDir;
|
|
Directory.CreateDirectory(outDir);
|
|
return true;
|
|
}
|
|
|
|
public bool Step2_DecryptAax()
|
|
{
|
|
DecryptProgressUpdate?.Invoke(this, 0);
|
|
|
|
var tempRipFile = Path.Combine(outDir, "funny.aac");
|
|
|
|
var fail = "WARNING-Decrypt failure. ";
|
|
|
|
int returnCode;
|
|
if (string.IsNullOrWhiteSpace(decryptKey))
|
|
{
|
|
returnCode = getKey_decrypt(tempRipFile);
|
|
}
|
|
else
|
|
{
|
|
returnCode = decrypt(tempRipFile);
|
|
if (returnCode == -99)
|
|
{
|
|
Console.WriteLine($"{fail}Incorrect decrypt key: {decryptKey}");
|
|
decryptKey = null;
|
|
returnCode = getKey_decrypt(tempRipFile);
|
|
}
|
|
}
|
|
|
|
if (returnCode == 100)
|
|
Console.WriteLine($"{fail}Thread completed without changing return code. This shouldn't be possible");
|
|
else if (returnCode == 0)
|
|
{
|
|
// success!
|
|
FileExt.SafeMove(tempRipFile, outputFileWithNewExt(".mp4"));
|
|
DecryptProgressUpdate?.Invoke(this, 100);
|
|
return true;
|
|
}
|
|
else if (returnCode == -99)
|
|
Console.WriteLine($"{fail}Incorrect decrypt key: {decryptKey}");
|
|
else // any other returnCode
|
|
Console.WriteLine($"{fail}Unknown failure code: {returnCode}");
|
|
|
|
FileExt.SafeDelete(tempRipFile);
|
|
DecryptProgressUpdate?.Invoke(this, 0);
|
|
return false;
|
|
}
|
|
|
|
private int getKey_decrypt(string tempRipFile)
|
|
{
|
|
getKey();
|
|
return decrypt(tempRipFile);
|
|
}
|
|
private void getKey()
|
|
{
|
|
Console.WriteLine("Discovering decrypt key");
|
|
|
|
Console.WriteLine("Getting file hash");
|
|
var checksum = BytesCracker.GetChecksum(inputFileName);
|
|
Console.WriteLine("File hash calculated: " + checksum);
|
|
|
|
Console.WriteLine("Cracking activation bytes");
|
|
var activation_bytes = BytesCracker.GetActivationBytes(checksum);
|
|
decryptKey = activation_bytes;
|
|
Console.WriteLine("Activation bytes cracked. Decrypt key: " + activation_bytes);
|
|
}
|
|
|
|
private int decrypt(string tempRipFile)
|
|
{
|
|
FileExt.SafeDelete(tempRipFile);
|
|
|
|
Console.WriteLine("Decrypting with key " + decryptKey);
|
|
|
|
var returnCode = 100;
|
|
var thread = new Thread(() => returnCode = ngDecrypt());
|
|
thread.Start();
|
|
|
|
double fileLen = new FileInfo(inputFileName).Length;
|
|
while (thread.IsAlive && returnCode == 100)
|
|
{
|
|
Thread.Sleep(500);
|
|
if (File.Exists(tempRipFile))
|
|
{
|
|
double tempLen = new FileInfo(tempRipFile).Length;
|
|
var percentProgress = tempLen / fileLen * 100.0;
|
|
DecryptProgressUpdate?.Invoke(this, (int)percentProgress);
|
|
}
|
|
}
|
|
|
|
return returnCode;
|
|
}
|
|
|
|
private int ngDecrypt()
|
|
{
|
|
var info = new ProcessStartInfo
|
|
{
|
|
FileName = DecryptSupportLibraries.mp4trackdumpPath,
|
|
Arguments = "-c " + encodingInfo.channels + " -r " + encodingInfo.sampleRate + " \"" + inputFileName + "\""
|
|
};
|
|
info.EnvironmentVariables["VARIABLE"] = decryptKey;
|
|
|
|
var result = info.RunHidden();
|
|
|
|
// bad checksum -- bad decrypt key
|
|
if (result.Output.Contains("checksums mismatch, aborting!"))
|
|
return -99;
|
|
|
|
return result.ExitCode;
|
|
}
|
|
|
|
// temp file names for steps 3, 4, 5
|
|
string tempChapsGuid { get; } = Guid.NewGuid().ToString().ToUpper().Replace("-", "");
|
|
string tempChapsPath => Path.Combine(outDir, $"tempChaps_{tempChapsGuid}.mp4");
|
|
string mp4_file => outputFileWithNewExt(".mp4");
|
|
string ff_txt_file => mp4_file + ".ff.txt";
|
|
|
|
public bool Step3_Chapterize()
|
|
{
|
|
var str1 = "";
|
|
if (chapters.FirstChapterStart != 0.0)
|
|
{
|
|
str1 = " -ss " + chapters.FirstChapterStart.ToString("0.000", CultureInfo.InvariantCulture) + " -t " + (chapters.LastChapterStart - 1.0).ToString("0.000", CultureInfo.InvariantCulture) + " ";
|
|
}
|
|
|
|
var ffmpegTags = tags.GenerateFfmpegTags();
|
|
var ffmpegChapters = chapters.GenerateFfmpegChapters();
|
|
File.WriteAllText(ff_txt_file, ffmpegTags + ffmpegChapters);
|
|
|
|
var tagAndChapterInfo = new ProcessStartInfo
|
|
{
|
|
FileName = DecryptSupportLibraries.ffmpegPath,
|
|
Arguments = "-y -i \"" + mp4_file + "\" -f ffmetadata -i \"" + ff_txt_file + "\" -map_metadata 1 -bsf:a aac_adtstoasc -c:a copy" + str1 + " -map 0 \"" + tempChapsPath + "\""
|
|
};
|
|
tagAndChapterInfo.RunHidden();
|
|
|
|
return true;
|
|
}
|
|
|
|
public bool Step4_InsertCoverArt()
|
|
{
|
|
// save cover image as temp file
|
|
var coverPath = Path.Combine(outDir, "cover-" + Guid.NewGuid() + ".jpg");
|
|
FileExt.CreateFile(coverPath, coverBytes);
|
|
|
|
var insertCoverArtInfo = new ProcessStartInfo
|
|
{
|
|
FileName = DecryptSupportLibraries.atomicParsleyPath,
|
|
Arguments = "\"" + tempChapsPath + "\" --encodingTool \"" + AppName + "\" --artwork \"" + coverPath + "\" --overWrite"
|
|
};
|
|
insertCoverArtInfo.RunHidden();
|
|
|
|
// delete temp file
|
|
FileExt.SafeDelete(coverPath);
|
|
|
|
return true;
|
|
}
|
|
|
|
public bool Step5_Cleanup()
|
|
{
|
|
FileExt.SafeDelete(mp4_file);
|
|
FileExt.SafeDelete(ff_txt_file);
|
|
FileExt.SafeMove(tempChapsPath, outputFileName);
|
|
|
|
return true;
|
|
}
|
|
|
|
public bool Step6_AddTags()
|
|
{
|
|
tags.AddAppleTags(outputFileName);
|
|
return true;
|
|
}
|
|
|
|
public bool End_CreateCue()
|
|
{
|
|
File.WriteAllText(outputFileWithNewExt(".cue"), Cue.CreateContents(Path.GetFileName(outputFileName), chapters));
|
|
return true;
|
|
}
|
|
|
|
public bool End_CreateNfo()
|
|
{
|
|
File.WriteAllText(outputFileWithNewExt(".nfo"), NFO.CreateContents(AppName, tags, encodingInfo, chapters));
|
|
return true;
|
|
}
|
|
}
|
|
}
|