public static IEnumerable <ConfigurationSection> GetConfigurationSections(IBassEncoderSettings settings)
{
yield return(new ConfigurationSection(SECTION, "Converter")
.WithElement(new SelectionConfigurationElement(DEPTH_ELEMENT, "Depth", path: settings.Name)
.WithOptions(GetDepthOptions())
));
}
public static IEnumerable <ConfigurationSection> GetConfigurationSections(IBassEncoderSettings settings)
{
yield return(new ConfigurationSection(SECTION, "Converter")
.WithElement(new SelectionConfigurationElement(DEPTH_ELEMENT, "Depth", path: settings.Name)
.WithOptions(GetDepthOptions())
.DependsOn(SECTION, ENABLED_ELEMENT))
.WithElement(new IntegerConfigurationElement(COMPRESSION_ELEMENT, "Compression Level", path: settings.Name)
.WithValue(DEFAULT_COMPRESSION)
.WithValidationRule(new IntegerValidationRule(MIN_COMPRESSION, MAX_COMPRESSION))
.DependsOn(SECTION, ENABLED_ELEMENT))
.WithElement(new IntegerConfigurationElement(PROCESSING_ELEMENT, "Additional Processing", path: settings.Name)
.WithValue(DEFAULT_PROCESSING)
.WithValidationRule(new IntegerValidationRule(MIN_PROCESSING, MAX_PROCESSING))
.DependsOn(SECTION, ENABLED_ELEMENT))
.WithElement(new BooleanConfigurationElement(HYBRID_ELEMENT, "Hybrid Lossy", path: settings.Name)
.WithValue(false)
.DependsOn(SECTION, ENABLED_ELEMENT))
.WithElement(new BooleanConfigurationElement(CORRECTION_ELEMENT, "Correction File", path: settings.Name)
.WithValue(false).DependsOn(SECTION, HYBRID_ELEMENT)
.DependsOn(SECTION, ENABLED_ELEMENT))
.WithElement(new IntegerConfigurationElement(BITRATE_ELEMENT, "Bitrate", path: settings.Name)
.WithValue(DEFAULT_BITRATE).DependsOn(SECTION, HYBRID_ELEMENT)
.WithValidationRule(new IntegerValidationRule(MIN_BITRATE, MAX_BITRATE))
.DependsOn(SECTION, ENABLED_ELEMENT)
));
}
public static IEnumerable <ConfigurationSection> GetConfigurationSections(IBassEncoderSettings settings)
{
yield return(new ConfigurationSection(SECTION, "Converter")
.WithElement(new IntegerConfigurationElement(BITRATE_ELEMENT, "Bitrate", path: settings.Name)
.WithValue(DEFAULT_BITRATE)
.WithValidationRule(new IntegerValidationRule(MIN_BITRATE, MAX_BITRATE))
));
}
public static IEnumerable <ConfigurationSection> GetConfigurationSections(IBassEncoderSettings settings)
{
yield return(new ConfigurationSection(SECTION, "Converter")
.WithElement(new SelectionConfigurationElement(BITRATE_ELEMENT, "Bitrate", path: settings.Name)
.WithOptions(GetBitrateOptions())
.DependsOn(SECTION, ENABLED_ELEMENT)
));
}
public static IEnumerable <ConfigurationSection> GetConfigurationSections(IBassEncoderSettings settings)
{
yield return(new ConfigurationSection(SECTION, "Converter")
.WithElement(new IntegerConfigurationElement(QUALITY_ELEMENT, "Quality", path: settings.Name)
.WithValue(DEFAULT_QUALITY)
.WithValidationRule(new IntegerValidationRule(MIN_QUALITY, MAX_QUALITY))
));
}
public static IEnumerable <ConfigurationSection> GetConfigurationSections(IBassEncoderSettings settings)
{
yield return(new ConfigurationSection(SECTION, "Converter")
.WithElement(new SelectionConfigurationElement(DEPTH_ELEMENT, "Depth", path: settings.Name)
.WithOptions(GetDepthOptions()))
.WithElement(new IntegerConfigurationElement(COMPRESSION_ELEMENT, "Compression Level", path: settings.Name)
.WithValue(DEFAULT_COMPRESSION)
.WithValidationRule(new IntegerValidationRule(MIN_COMPRESSION, MAX_COMPRESSION))
));
}
protected virtual void Encode(EncoderItem encoderItem, IBassEncoderSettings settings)
{
var flags = BassFlags.Decode;
if (this.ShouldDecodeFloat(encoderItem, settings))
{
Logger.Write(this, LogLevel.Debug, "Decoding file \"{0}\" in high quality mode (32 bit floating point).", encoderItem.InputFileName);
flags |= BassFlags.Float;
}
else
{
Logger.Write(this, LogLevel.Debug, "Decoding file \"{0}\" in standaed quality mode (16 bit integer).", encoderItem.InputFileName);
}
var stream = this.CreateStream(encoderItem.InputFileName, flags);
if (stream.IsEmpty)
{
Logger.Write(this, LogLevel.Debug, "Failed to create stream for file \"{0}\": Unknown error.", encoderItem.InputFileName);
return;
}
Logger.Write(this, LogLevel.Debug, "Created stream for file \"{0}\": {1}", encoderItem.InputFileName, stream.ChannelHandle);
try
{
if (flags.HasFlag(BassFlags.Float))
{
this.EncodeWithResampler(encoderItem, stream, settings);
}
else
{
this.Encode(encoderItem, stream, settings);
}
}
finally
{
Logger.Write(this, LogLevel.Debug, "Releasing stream for file \"{0}\": {1}", encoderItem.InputFileName, stream.ChannelHandle);
Bass.StreamFree(stream.ChannelHandle); //Not checking result code as it contains an error if the application is shutting down.
}
if (this.CancellationToken.IsCancellationRequested)
{
encoderItem.Status = EncoderItemStatus.Cancelled;
if (File.Exists(encoderItem.OutputFileName))
{
Logger.Write(this, LogLevel.Debug, "Deleting incomplete output \"{0}\": Cancelled.", encoderItem.OutputFileName);
File.Delete(encoderItem.OutputFileName);
}
}
else
{
encoderItem.Status = EncoderItemStatus.Complete;
}
}
protected virtual void Encode(EncoderItem encoderItem, IBassStream stream, IBassEncoderSettings settings)
{
using (var encoderProcess = this.CreateEncoderProcess(encoderItem, stream, settings))
{
this.Encode(encoderItem, stream, encoderProcess);
if (this.WaitForExit(encoderProcess))
{
if (encoderProcess.ExitCode != 0)
{
throw new InvalidOperationException("Process does not indicate success.");
}
}
}
}
protected virtual bool ShouldDecodeFloat(EncoderItem encoderItem, IBassEncoderSettings settings)
{
if (encoderItem.BitsPerSample == 1)
{
Logger.Write(this, LogLevel.Debug, "Suggesting high quality mode for file \"{0}\": dsd.", encoderItem.InputFileName);
return(true);
}
if (encoderItem.BitsPerSample > 16 || settings.Format.Depth > 16)
{
Logger.Write(this, LogLevel.Debug, "Suggesting high quality mode for file \"{0}\": >16 bit.", encoderItem.InputFileName);
return(true);
}
Logger.Write(this, LogLevel.Debug, "Suggesting standard quality mode for file \"{0}\": <=16 bit.", encoderItem.InputFileName);
return(false);
}
public static IEnumerable <ConfigurationSection> GetConfigurationSections(IBassEncoderSettings settings)
{
yield return(new ConfigurationSection(SECTION)
.WithElement(new SelectionConfigurationElement(DEPTH_ELEMENT, "Depth", path: settings.Name)
.WithOptions(GetDepthOptions())
.DependsOn(SECTION, ENABLED_ELEMENT))
.WithElement(new IntegerConfigurationElement(COMPRESSION_ELEMENT, "Compression Level", path: settings.Name)
.WithValue(DEFAULT_COMPRESSION)
.WithValidationRule(new IntegerValidationRule(MIN_COMPRESSION, MAX_COMPRESSION))
.DependsOn(SECTION, ENABLED_ELEMENT))
.WithElement(new BooleanConfigurationElement(IGNORE_ERRORS_ELEMENT, "Ignore Errors", path: settings.Name)
.WithValue(true)
.DependsOn(SECTION, ENABLED_ELEMENT)
));
}
protected virtual Process CreateEncoderProcess(EncoderItem encoderItem, IBassStream stream, IBassEncoderSettings settings)
{
Logger.Write(this, LogLevel.Debug, "Creating encoder process for file \"{0}\".", encoderItem.InputFileName);
var arguments = settings.GetArguments(encoderItem, stream);
var process = this.CreateProcess(
encoderItem,
stream,
settings.Executable,
settings.Directory,
arguments,
true,
false,
true
);
Logger.Write(this, LogLevel.Debug, "Created encoder process for file \"{0}\": \"{1}\" {2}", encoderItem.InputFileName, settings.Executable, arguments);
return(process);
}
protected virtual void EncodeWithResampler(EncoderItem encoderItem, IBassStream stream, IBassEncoderSettings settings)
{
using (var resamplerProcess = this.CreateResamplerProcess(encoderItem, stream, new SoxEncoderSettings(settings)))
{
using (var encoderProcess = this.CreateEncoderProcess(encoderItem, stream, settings))
{
var success = true;
this.EncodeWithResampler(encoderItem, stream, resamplerProcess, encoderProcess);
if (this.WaitForExit(resamplerProcess))
{
if (resamplerProcess.ExitCode != 0)
{
success = false;
}
}
if (this.WaitForExit(encoderProcess))
{
if (encoderProcess.ExitCode != 0)
{
success = false;
}
}
if (!success)
{
throw new InvalidOperationException("Process does not indicate success.");
}
}
}
}
public SoxEncoderSettings(IBassEncoderSettings settings) : this()
{
this.Settings = settings;
}
protected virtual void Encode(IBassEncoderSettings settings)
{
if (settings.Threads > 1)
{
Logger.Write(this, LogLevel.Debug, "Beginning parallel encoding with {0} threads.", settings.Threads);
}
else
{
Logger.Write(this, LogLevel.Debug, "Beginning single threaded encoding.");
}
var parallelOptions = new ParallelOptions()
{
MaxDegreeOfParallelism = settings.Threads
};
Parallel.ForEach(this.EncoderItems, parallelOptions, encoderItem =>
{
try
{
if (this.CancellationToken.IsCancellationRequested)
{
Logger.Write(this, LogLevel.Warn, "Skipping file \"{0}\" due to cancellation.", encoderItem.InputFileName);
encoderItem.Status = EncoderItemStatus.Cancelled;
return;
}
encoderItem.OutputFileName = settings.GetOutput(encoderItem.InputFileName);
if (!this.CheckInput(encoderItem.InputFileName))
{
Logger.Write(this, LogLevel.Warn, "Skipping file \"{0}\" due to output file \"{1}\" does not exist.", encoderItem.InputFileName, encoderItem.OutputFileName);
encoderItem.Status = EncoderItemStatus.Failed;
encoderItem.AddError(string.Format("Input file \"{0}\" does not exist.", encoderItem.OutputFileName));
return;
}
if (!this.CheckOutput(encoderItem.OutputFileName))
{
Logger.Write(this, LogLevel.Warn, "Skipping file \"{0}\" due to output file \"{1}\" already exists or cannot be written.", encoderItem.InputFileName, encoderItem.OutputFileName);
encoderItem.Status = EncoderItemStatus.Failed;
encoderItem.AddError(string.Format("Output file \"{0}\" already exists or cannot be written.", encoderItem.OutputFileName));
return;
}
Logger.Write(this, LogLevel.Debug, "Beginning encoding file \"{0}\" to output file \"{1}\".", encoderItem.InputFileName, encoderItem.OutputFileName);
encoderItem.Progress = EncoderItem.PROGRESS_NONE;
encoderItem.Status = EncoderItemStatus.Processing;
this.Encode(encoderItem, settings);
if (encoderItem.Status == EncoderItemStatus.Complete)
{
Logger.Write(this, LogLevel.Debug, "Encoding file \"{0}\" to output file \"{1}\" completed successfully.", encoderItem.InputFileName, encoderItem.OutputFileName);
}
else
{
Logger.Write(this, LogLevel.Warn, "Encoding file \"{0}\" failed: Unknown error.", encoderItem.InputFileName);
}
}
catch (OperationCanceledException)
{
Logger.Write(this, LogLevel.Warn, "Skipping file \"{0}\" due to cancellation.", encoderItem.InputFileName);
encoderItem.Status = EncoderItemStatus.Cancelled;
return;
}
catch (Exception e)
{
Logger.Write(this, LogLevel.Warn, "Encoding file \"{0}\" failed: {1}", encoderItem.InputFileName, e.Message);
encoderItem.Status = EncoderItemStatus.Failed;
encoderItem.AddError(e.Message);
}
finally
{
encoderItem.Progress = EncoderItem.PROGRESS_COMPLETE;
}
});
Logger.Write(this, LogLevel.Debug, "Encoding completed successfully.");
}
