void DoExport(ISampleEncoder encoder, Stream outputStream, SettingsDictionary settings, CancellationToken cancelToken)
{
Contract.Requires(encoder != null);
Contract.Requires(outputStream != null);
Contract.Requires(settings != null);
encoder.Initialize(outputStream, AudioInfo, Metadata, settings);
using (FileStream inputStream = FileInfo.OpenRead())
{
// Try each decoder that supports this file extension:
foreach (ExportFactory <ISampleDecoder> decoderFactory in
ExtensionProvider.GetFactories <ISampleDecoder>("Extension", FileInfo.Extension))
{
try
{
using (ExportLifetimeContext <ISampleDecoder> decoderLifetime = decoderFactory.CreateExport())
{
ISampleDecoder sampleDecoder = decoderLifetime.Value;
sampleDecoder.Initialize(inputStream);
sampleDecoder.ReadWriteParallel(encoder, cancelToken, encoder.ManuallyFreesSamples);
return;
}
}
catch (UnsupportedAudioException)
{
// If a decoder wasn't supported, rewind the stream and try another:
inputStream.Position = 0;
}
}
throw new UnsupportedAudioException(Resources.AudioFileDecodeError);
}
}
public void Initialize(MetadataDictionary metadata, SettingsDictionary settings)
{
Contract.Requires <ArgumentNullException>(metadata != null);
Contract.Requires <ArgumentNullException>(settings != null);
}
public ExportableAudioFile Export(string encoder, CancellationToken cancelToken, SettingsDictionary settings = null, DirectoryInfo outputDirectory = null, string outputFileName = null, bool replaceExisting = false)
{
Contract.Requires <ArgumentNullException>(!string.IsNullOrEmpty(encoder));
Contract.Ensures(Contract.Result <ExportableAudioFile>() != null);
if (settings == null)
{
settings = new SettingsDictionary();
}
ExportFactory <ISampleEncoder> encoderFactory =
ExtensionProvider.GetFactories <ISampleEncoder>("Name", encoder).SingleOrDefault();
if (encoderFactory == null)
{
throw new ArgumentException(
string.Format(CultureInfo.CurrentCulture, Resources.ExportableAudioFileFactoryError, encoder),
nameof(encoder));
}
ExportLifetimeContext <ISampleEncoder> encoderLifetime = null;
FileInfo outputFileInfo = null;
FileInfo finalOutputFileInfo;
FileStream outputStream = null;
try
{
try
{
encoderLifetime = encoderFactory.CreateExport();
ValidateSettings(settings, encoderLifetime.Value);
outputFileInfo = finalOutputFileInfo = GetOutputFileInfo(FileInfo, outputDirectory, outputFileName, encoderLifetime.Value);
// If the output file already exists, write to a temporary file first:
if (outputFileInfo.Exists)
{
outputFileInfo = new FileInfo(Path.Combine(outputFileInfo.DirectoryName ?? string.Empty, Path.GetRandomFileName()));
if (!replaceExisting)
{
throw new IOException(string.Format(CultureInfo.CurrentCulture,
Resources.ExportableAudioFileFileExistsError, finalOutputFileInfo.FullName));
}
}
outputStream = new FileStream(outputFileInfo.FullName, replaceExisting ? FileMode.Create : FileMode.CreateNew, FileAccess.ReadWrite);
DoExport(encoderLifetime.Value, outputStream, settings, cancelToken);
}
finally
{
// Dispose the encoder before closing the output stream:
encoderLifetime?.Dispose();
outputStream?.Dispose();
}
}
catch (Exception)
{
outputFileInfo?.Delete();
throw;
}
// If using a temporary file, replace the original:
if (outputFileInfo != finalOutputFileInfo)
{
finalOutputFileInfo.Delete();
outputFileInfo.MoveTo(finalOutputFileInfo.FullName);
}
outputFileInfo.Refresh();
return(new ExportableAudioFile(outputFileInfo));
}
public void Initialize(Stream stream, AudioInfo audioInfo, MetadataDictionary metadata, SettingsDictionary settings)
{
Contract.Requires <ArgumentNullException>(stream != null);
Contract.Requires <ArgumentException>(stream.CanRead);
Contract.Requires <ArgumentException>(stream.CanWrite);
Contract.Requires <ArgumentException>(stream.CanSeek);
Contract.Requires <ArgumentException>(stream.Position == 0);
Contract.Requires(audioInfo != null);
Contract.Requires(metadata != null);
Contract.Requires(settings != null);
}
