public IEncoder CreateEncoder(int threadNumber, IParallelTask _task)
{
if (_task is ReplayGainTask)
{
ReplayGainTask task = (ReplayGainTask)_task;
return(new ReplayGainTagEncoder(task));
}
else if (_task is FileEncodeTask)
{
FileEncodeTask task = (FileEncodeTask)_task;
IAudioSource audioSource = task.AudioSourceLazy();
if (audioSource == null)
{
throw new SkipEncodingItemException("Unsupported audio format.");
}
if (this.CalculateReplayGain)
{
task.TrackGain = DspHelper.CreateTrackGain(audioSource);
}
if (this.CalculateDynamicRange)
{
task.DrMeter = DspHelper.CreateDrMeter(audioSource);
}
return(new DspCalculatorEncoder(audioSource, task.TrackGain, task.DrMeter));
}
throw new NotSupportedException();
}
public override void TryDeleteResult(IParallelTask _task)
{
FileEncodeTask task = (FileEncodeTask)_task;
Utility.TryDeleteFile(task.TargetFilename);
Utility.TryDeleteEmptyFoldersToTheRoot(Path.GetDirectoryName(task.TargetFilename));
}
private List<IParallelTask> GenerateReplayGainTasks(Release[] releases, IProgress<double> progress)
{
List<IParallelTask> tasks = new List<IParallelTask>();
DspEncoderFactory replayGainFactory = new DspEncoderFactory(this.settingsManager.Settings.LocalConcurrencyLevel, true, false);
double progressCoef = 1.0 / releases.Length;
int processed = 0;
foreach (Release release in releases)
{
ReplayGainTask rgTask = new ReplayGainTask(replayGainFactory, release, true, true, false);
foreach (Track track in release.Tracklist)
{
string filename = Path.Combine(this.CollectionManager.Settings.MusicDirectory, track.RelativeFilename);
var task = new FileEncodeTask(replayGainFactory, () => AudioHelper.GetAudioSourceForFile(filename), filename, null);
tasks.Add(task);
rgTask.AddItem(track, task);
}
tasks.Add(rgTask);
++processed;
progress.Report(processed * progressCoef);
}
return tasks;
}
private void ComputeReplayGain()
{
this.OnProgressChanged(new ProgressChangedEventArgs(0));
if (this.replayGainTask.RecalculateReplayGain)
{
this.replayGainTask.AlbumGain = new AlbumGain();
var albumGainData = this.replayGainTask.AlbumGain;
for (int i = 0; i < trackTasks.Count; ++i)
{
FileEncodeTask task = this.trackTasks[i].Task;
this.trackTasks[i].Track.ReplayGainTrackGain = task.TrackGain.GetGain();
this.trackTasks[i].Track.ReplayGainTrackPeak = task.TrackGain.GetPeak();
albumGainData.AppendTrackData(task.TrackGain);
this.OnProgressChanged(new ProgressChangedEventArgs((double)(i + 1) / trackTasks.Count / 2));
}
this.replayGainTask.Release.ReplayGainAlbumGain = albumGainData.GetGain();
this.replayGainTask.Release.ReplayGainAlbumPeak = albumGainData.GetPeak();
}
if (this.replayGainTask.SaveDynamicRange)
{
foreach (ReplayGainTask.Item item in this.trackTasks)
{
item.Track.DynamicRange = item.Task.DrMeter.GetDynamicRange();
}
}
for (int i = 0; i < trackTasks.Count; ++i)
{
FileEncodeTask task = this.trackTasks[i].Task;
Track track = this.trackTasks[i].Track;
double trackGain = track.ReplayGainTrackGain;
double trackPeak = this.replayGainTask.WritePeaks ? track.ReplayGainTrackPeak : double.NaN;
double albumGain = this.replayGainTask.Release.ReplayGainAlbumGain;
double albumPeak = this.replayGainTask.WritePeaks ? this.replayGainTask.Release.ReplayGainAlbumPeak : double.NaN;
AudioFileTag.WriteReplayGainData(task.TargetFilename, trackGain, trackPeak, albumGain, albumPeak, true);
this.OnProgressChanged(new ProgressChangedEventArgs(0.5 + (double)(i + 1) / trackTasks.Count / 2));
}
for (int i = 0; i < trackTasks.Count; ++i)
{
if (this.trackTasks[i].Task.TrackGain != null)
{
this.trackTasks[i].Task.TrackGain.Dispose();
}
}
}
protected IAudioSource SetupTask(FileEncodeTask task)
{
IAudioSource audioSource = task.AudioSourceLazy();
if (audioSource == null)
{
throw new SkipEncodingItemException("Audio source is not supported.");
}
if (this.CalculateRg)
{
task.TrackGain = DspHelper.CreateTrackGain(audioSource);
}
if (this.CalculateDr)
{
task.DrMeter = DspHelper.CreateDrMeter(audioSource);
}
return audioSource;
}
public IEncoder CreateEncoder(int threadNumber, IParallelTask _task)
{
FileEncodeTask task = (FileEncodeTask)_task;
IAudioSource audioSource = this.SetupTask(task);
try
{
return(this.CreateEncoderInternal(threadNumber, task, audioSource));
}
catch
{
if (audioSource != null)
{
audioSource.Close();
}
throw;
}
}
protected IAudioSource SetupTask(FileEncodeTask task)
{
IAudioSource audioSource = task.AudioSourceLazy();
if (audioSource == null)
{
throw new SkipEncodingItemException("Audio source is not supported.");
}
if (this.CalculateRg)
{
task.TrackGain = DspHelper.CreateTrackGain(audioSource);
}
if (this.CalculateDr)
{
task.DrMeter = DspHelper.CreateDrMeter(audioSource);
}
return(audioSource);
}
protected override IEncoder CreateEncoderInternal(int threadNumber, FileEncodeTask task, IAudioSource audioSource)
{
if (threadNumber < this.concurrencylevel)
{
return new NativeFlacEncoder(audioSource, task.TargetFilename, task.Tag, compressionLevel, task.TrackGain, task.DrMeter);
}
threadNumber -= this.concurrencylevel;
foreach (DiscoveryServerDescriptor server in this.servers)
{
if (threadNumber < server.ThreadCount)
{
return new RemoteFlacEncoder(server.Address, audioSource, task.TargetFilename, task.Tag, this.compressionLevel, task.TrackGain, task.DrMeter);
}
threadNumber -= server.ThreadCount;
}
throw new ArgumentException("threadNumber is too large.");
}
protected override IEncoder CreateEncoderInternal(int threadNumber, FileEncodeTask task, IAudioSource audioSource)
{
if (threadNumber < this.localConcurrency)
{
return new LocalMp3Encoder(audioSource, task.TargetFilename, task.Tag, vbrQuality, task.TrackGain, task.DrMeter);
}
threadNumber -= Environment.ProcessorCount;
foreach (DiscoveryServerDescriptor server in this.servers)
{
if (threadNumber < server.ThreadCount)
{
return new RemoteMp3VbrEncoder(server.Address, audioSource, task.TargetFilename, task.Tag, this.vbrQuality, task.TrackGain, task.DrMeter);
}
threadNumber -= server.ThreadCount;
}
throw new ArgumentException("threadNumber is too large.");
}
private void GenerateDynamicRangeTasks(Release[] releases, IProgress<double> progress)
{
DspEncoderFactory replayGainFactory = new DspEncoderFactory(this.settingsManager.Settings.LocalConcurrencyLevel, false, true);
double progressCoef = 1.0 / releases.Length;
int processed = 0;
foreach (Release release in releases)
{
foreach (Track track in release.Tracklist)
{
string filename = Path.Combine(this.CollectionManager.Settings.MusicDirectory, track.RelativeFilename);
var task = new FileEncodeTask(replayGainFactory, () => AudioHelper.GetAudioSourceForFile(filename), filename, null);
this.trackToTask[track] = task;
this.tasks.Add(task);
}
++processed;
progress.Report(processed * progressCoef);
}
}
private void btnSync_Click(object sender, System.Windows.RoutedEventArgs e)
{
bool successfullyDeletedFiles = true;
foreach (string fileToDelete in this.scanResult.FilesToDelete)
{
successfullyDeletedFiles = Utility.TryDeleteFile(fileToDelete) && successfullyDeletedFiles;
successfullyDeletedFiles = Utility.TryDeleteEmptyFoldersToTheRoot(Path.GetDirectoryName(fileToDelete)) && successfullyDeletedFiles;
}
if (!successfullyDeletedFiles)
{
Dialogs.Inform("Some files or folders were not successfully deleted. Please unlock them and rerun the sync.");
}
if (this.scanResult.ReleasesToEncode.Count > 0)
{
int localConcurrencyLevel = this.SettingsManager.Settings.ActualLocalConcurrencyLevel;
IEncoderFactory encoderFactory;
if (this.CollectionManager.Settings.NetworkEncoding)
{
encoderFactory = new RemoteMp3EncoderFactory(this.networkBox.Servers, this.encodingTarget.Mp3Settings.VbrQuality, localConcurrencyLevel, false, false);
}
else
{
encoderFactory = new LocalMp3EncoderFactory(this.encodingTarget.Mp3Settings.VbrQuality, localConcurrencyLevel, false, false);
}
IEncoderFactory replayGainFactory = new DspEncoderFactory(this.SettingsManager.Settings.ActualLocalConcurrencyLevel, false, false);
List<IParallelTask> tasks = new List<IParallelTask>();
foreach (var release in this.scanResult.ReleasesToEncode)
{
var rgTask = new ReplayGainTask(replayGainFactory, release, false, false, false);
if (!release.Tracklist.All(t => AudioHelper.IsSupportedAudioSource(t.RelativeFilename)))
{
continue;
}
foreach (Track track in release.Tracklist)
{
string sourceFilename = Path.Combine(this.CollectionManager.Settings.MusicDirectory, track.RelativeFilename);
string targetRelativeFilename = FilenameGenerator.PatternToFilename(this.encodingTarget.FileNamingPattern, release, track) + this.encodingTarget.Extension;
string targetFilename = Path.Combine(this.encodingTarget.TargetDirectory, targetRelativeFilename);
AudioFileTag tag = new AudioFileTag(release, track);
FileEncodeTask encodeTask = new FileEncodeTask(
encoderFactory,
() => AudioHelper.GetAudioSourceForFile(sourceFilename),
targetFilename,
tag
);
encodeTask.ProgressChanged += (_sender, _e) =>
{
if (encodeTask.Status == EncodeTaskStatus.Completed)
{
FileInfo originalFileInfo = new FileInfo(sourceFilename);
File.SetCreationTime(targetFilename, originalFileInfo.CreationTime);
File.SetLastWriteTime(targetFilename, originalFileInfo.LastWriteTime);
File.SetLastAccessTime(targetFilename, originalFileInfo.LastAccessTime);
}
};
tasks.Add(encodeTask);
rgTask.AddItem(track, encodeTask);
}
tasks.Add(rgTask);
}
int concurrency = Math.Max(encoderFactory.ThreadCount, replayGainFactory.ThreadCount);
EncoderController controller = new EncoderController(tasks.ToArray(), concurrency);
controller.DeleteSuccessfullyEncodedItemsIfFailure = false;
EncodingWindow window = new EncodingWindow(controller);
window.ShowDialog(this);
}
this.Close();
}
protected override IEncoder CreateEncoderInternal(int threadNumber, FileEncodeTask task, IAudioSource audioSource)
{
return(new CueToolsFlacEncoder(audioSource, task.TargetFilename, task.Tag, 8, task.TrackGain, task.DrMeter));
}
protected abstract IEncoder CreateEncoderInternal(int threadNumber, FileEncodeTask task, IAudioSource audioSource);
private void OKCancelBox_OKClicked(object sender, EventArgs e)
{
this.release.DateAudioModified = DateTime.Now;
IEncoderFactory encoderFactory;
if (this.CollectionManager.Settings.NetworkEncoding)
{
encoderFactory = new RemoteFlacEncoderFactory(this.networkBox.Servers, 8, this.SettingsManager.Settings.ActualLocalConcurrencyLevel, true, true);
}
else
{
encoderFactory = new NativeFlacEncoderFactory(8, this.SettingsManager.Settings.ActualLocalConcurrencyLevel, true, true);
}
IEncoderFactory replayGainFactory = new DspEncoderFactory(this.SettingsManager.Settings.ActualLocalConcurrencyLevel, true, true);
ReplayGainTask rgTask = new ReplayGainTask(replayGainFactory, this.release, true, true, true);
List<IParallelTask> tasks = new List<IParallelTask>();
for (int i = 0; i < this.items.Count; ++i)
{
Track track = this.release.Tracklist[i];
IImportSourceItem importSourceItem = this.items[i];
track.RelativeFilename = FilenameGenerator.PatternToFilename(
this.CollectionManager.Settings.FileNamingPattern,
this.release, track) + ".flac";
AudioFileTag tag = new AudioFileTag(this.release, track);
string filename = Path.Combine(this.CollectionManager.Settings.MusicDirectory, track.RelativeFilename);
var task = new FileEncodeTask(
encoderFactory,
() => importSourceItem.GetAudioSource(),
filename,
tag
);
tasks.Add(task);
rgTask.AddItem(track, task);
}
tasks.Add(rgTask);
int concurrency = Math.Max(encoderFactory.ThreadCount, replayGainFactory.ThreadCount);
EncoderController controller = new EncoderController(tasks.ToArray(), concurrency);
EncodingWindow window = new EncodingWindow(controller);
if (window.ShowDialog(this) == true)
{
this.release.UpdateDynamicProperties();
this.CollectionManager.Save(this.release);
this.Close();
}
CollectionManagerGlobal.OnCollectionChanged();
}
protected override IEncoder CreateEncoderInternal(int threadNumber, FileEncodeTask task, IAudioSource audioSource)
{
return new NativeFlacEncoder(audioSource, task.TargetFilename, task.Tag, this.CompressionLevel, task.TrackGain, task.DrMeter);
}
protected override IEncoder CreateEncoderInternal(int threadNumber, FileEncodeTask task, IAudioSource audioSource)
{
return new LocalMp3Encoder(audioSource, task.TargetFilename, task.Tag, this.VbrQuality, task.TrackGain, task.DrMeter);
}
public Item(Track track, FileEncodeTask task)
{
this.Track = track;
this.Task = task;
}
private void OKCancelBox_OKClicked(object sender, System.EventArgs e)
{
this.UpdateRelease();
IEncoderFactory encoderFactory;
if (this.CollectionManager.Settings.NetworkEncoding)
{
encoderFactory = new RemoteFlacEncoderFactory(this.networkBox.Servers, 8, this.SettingsManager.Settings.ActualLocalConcurrencyLevel, true, true);
}
else
{
encoderFactory = new NativeFlacEncoderFactory(8, this.SettingsManager.Settings.ActualLocalConcurrencyLevel, true, true);
}
IEncoderFactory replayGainFactory = new DspEncoderFactory(this.SettingsManager.Settings.ActualLocalConcurrencyLevel, true, true);
ReplayGainTask rgTask = new ReplayGainTask(replayGainFactory, this.DatabaseRelease, true, true, true);
List<IParallelTask> tasks = new List<IParallelTask>();
foreach (Track track in this.DatabaseRelease.Tracklist)
{
track.RelativeFilename = FilenameGenerator.PatternToFilename(
this.CollectionManager.Settings.FileNamingPattern,
this.DatabaseRelease, track) + ".flac";
AudioFileTag tag = new AudioFileTag(this.DatabaseRelease, track);
IImportSourceItem sourceItem = this.Release.Discs[track.Disc - 1][track.Position - 1].SourceItem;
string filename = Path.Combine(this.CollectionManager.Settings.MusicDirectory, track.RelativeFilename);
var task = new FileEncodeTask(
encoderFactory,
() => sourceItem.GetAudioSource(),
filename,
tag
);
tasks.Add(task);
rgTask.AddItem(track, task);
}
tasks.Add(rgTask);
int concurrency = Math.Max(encoderFactory.ThreadCount, replayGainFactory.ThreadCount);
EncoderController controller = new EncoderController(tasks.ToArray(), concurrency);
EncodingWindow window = new EncodingWindow(controller);
if (window.ShowDialog(this) == true)
{
this.DatabaseRelease.UpdateDynamicProperties();
this.CollectionManager.Save(this.DatabaseRelease);
this.InsertedReleaseId = this.DatabaseRelease.Id;
this.imagesEditor.WriteFiles();
CollectionManagerGlobal.OnCollectionChanged();
this.completed = true;
this.DialogResult = true;
}
}
public void AddItem(Track track, FileEncodeTask task)
{
this.TrackTasks.Add(new Item(track, task));
}
public Item(Track track, FileEncodeTask task)
{
this.Track = track;
this.Task = task;
}
public void AddItem(Track track, FileEncodeTask task)
{
this.TrackTasks.Add(new Item(track, task));
}
protected override IEncoder CreateEncoderInternal(int threadNumber, FileEncodeTask task, IAudioSource audioSource)
{
return new CueToolsFlacEncoder(audioSource, task.TargetFilename, task.Tag, 8, task.TrackGain, task.DrMeter);
}
protected abstract IEncoder CreateEncoderInternal(int threadNumber, FileEncodeTask task, IAudioSource audioSource);
