public void Initialize(Stream stream, AudioInfo audioInfo, MetadataDictionary metadata, SettingsDictionary settings)
{
Contract.Ensures(_encoder != null);
// Load the external gain filter:
ExportFactory <ISampleFilter> sampleFilterFactory =
ExtensionProvider.GetFactories <ISampleFilter>("Name", "ReplayGain").SingleOrDefault();
if (sampleFilterFactory == null)
{
throw new ExtensionInitializationException(Resources.SampleEncoderReplayGainFilterError);
}
_replayGainFilterLifetime = sampleFilterFactory.CreateExport();
_replayGainFilterLifetime.Value.Initialize(metadata, settings);
// Call the external ID3 encoder:
ExportFactory <IMetadataEncoder> metadataEncoderFactory =
ExtensionProvider.GetFactories <IMetadataEncoder>("Extension", EncoderInfo.FileExtension).Single();
if (metadataEncoderFactory == null)
{
throw new ExtensionInitializationException(string.Format(CultureInfo.CurrentCulture,
Resources.SampleEncoderMetadataEncoderError, EncoderInfo.FileExtension));
}
using (ExportLifetimeContext <IMetadataEncoder> metadataEncoderLifetime = metadataEncoderFactory.CreateExport())
metadataEncoderLifetime.Value.WriteMetadata(stream, metadata, settings);
_encoder = InitializeEncoder(audioInfo, stream);
ConfigureEncoder(settings, _encoder);
if (_encoder.InitializeParams() != 0)
{
throw new IOException(Resources.SampleEncoderFailedToInitialize);
}
}
public void Initialize(Stream stream, AudioInfo audioInfo, MetadataDictionary metadata, SettingsDictionary settings)
{
_encoder = new NativeVorbisEncoder();
_output = stream;
// Load the external gain filter:
ExportFactory <ISampleFilter> sampleFilterFactory =
ExtensionProvider.GetFactories <ISampleFilter>("Name", "ReplayGain").SingleOrDefault();
if (sampleFilterFactory == null)
{
throw new ExtensionInitializationException(Resources.SampleEncoderReplayGainFilterError);
}
_replayGainFilterLifetime = sampleFilterFactory.CreateExport();
_replayGainFilterLifetime.Value.Initialize(metadata, settings);
_oggStream = IntializeOggStream(settings);
_buffer = new byte[4096];
if (!string.IsNullOrEmpty(settings["BitRate"]))
{
ConfigureEncoderForBitRate(settings, audioInfo, _encoder);
}
else
{
ConfigureEncoderForQuality(settings, audioInfo, _encoder);
}
WriteHeader(metadata, stream);
}
public void Initialize(Stream stream, AudioInfo info, AudioMetadata metadata, SettingDictionary settings)
{
_stream = stream;
InitializeReplayGainFilter(info, metadata, settings);
// Call the external ID3 encoder, if available
var metadataEncoderFactory =
ExtensionProvider.GetFactories <IAudioMetadataEncoder>("Extension", FileExtension).FirstOrDefault();
if (metadataEncoderFactory != null)
{
using (var export = metadataEncoderFactory.CreateExport())
using (var tempStream = new MemoryStream())
{
// Buffer the tag in memory
export.Value.WriteMetadata(tempStream, metadata, settings);
// Pre-allocate the whole stream (estimate worst case of 320kbps, plus the tag)
stream.SetLength(0xA000 * (long)info.PlayLength.TotalSeconds + tempStream.Length);
// Flush the tag to the output stream
tempStream.WriteTo(stream);
}
}
_encoder = new(stream);
_encoder.SetChannels(info.Channels);
_encoder.SetSampleRate(info.SampleRate);
if (info.FrameCount > 0)
{
_encoder.SetSampleCount((uint)info.FrameCount);
}
if (settings.TryGetValue("BitRate", out int bitRate))
{
// Use ABR, unless ForceCBR is set to true
if (settings.TryGetValue("ForceCBR", out bool forceCbr) && forceCbr)
{
_encoder.SetBitRate(bitRate);
}
else
{
_encoder.SetVbrMeanBitRate(bitRate);
_encoder.SetVbrMode(VbrMode.Abr);
}
}
else
{
// Use VBR quality 3 if nothing else is specified
_encoder.SetVbrQuality(
settings.TryGetValue("VBRQuality", out int vbrQuality)
? vbrQuality
: 3);
_encoder.SetVbrMode(VbrMode.Mtrh);
}
_encoder.InitializeParameters();
}
protected override void ProcessRecord()
{
foreach (ExportFactory <ISampleEncoder> encoderFactory in string.IsNullOrEmpty(Name)
? ExtensionProvider.GetFactories <ISampleEncoder>()
: ExtensionProvider.GetFactories <ISampleEncoder>("Name", Name))
{
using (ExportLifetimeContext <ISampleEncoder> encoderLifetime = encoderFactory.CreateExport())
WriteObject(encoderLifetime.Value.EncoderInfo);
}
}
protected override void ProcessRecord()
{
foreach (ExportFactory <IMetadataEncoder> factory in string.IsNullOrEmpty(Extension)
? ExtensionProvider.GetFactories <IMetadataEncoder>()
: ExtensionProvider.GetFactories <IMetadataEncoder>("Extension", Extension))
{
using (ExportLifetimeContext <IMetadataEncoder> encoderLifetime = factory.CreateExport())
WriteObject(encoderLifetime.Value.EncoderInfo);
}
}
void InitializeReplayGainFilter(AudioInfo info, AudioMetadata metadata, SettingDictionary settings)
{
var filterFactory =
ExtensionProvider.GetFactories <IAudioFilter>("Name", "ReplayGain").FirstOrDefault();
if (filterFactory == null)
{
return;
}
_replayGainExport = filterFactory.CreateExport();
_replayGainExport.Value.Initialize(info, metadata, settings);
}
void InitializeReplayGainFilter(
[NotNull] AudioInfo info,
[NotNull] AudioMetadata metadata,
[NotNull] SettingDictionary settings)
{
var filterFactory =
ExtensionProvider.GetFactories <IAudioFilter>("Name", "ReplayGain").FirstOrDefault();
if (filterFactory == null)
{
return;
}
_replayGainExport = filterFactory.CreateExport();
// ReSharper disable once PossibleNullReferenceException
_replayGainExport.Value.Initialize(info, metadata, settings);
}
public void Finish()
{
_audioFile !.Dispose();
_audioFile = null;
_stream !.Position = 0;
// Call the external MP4 encoder for writing iTunes-compatible atoms
var metadataEncoderFactory =
ExtensionProvider.GetFactories <IAudioMetadataEncoder>("Extension", FileExtension).FirstOrDefault();
if (metadataEncoderFactory == null)
{
return;
}
using (var export = metadataEncoderFactory.CreateExport())
export.Value.WriteMetadata(_stream, _metadata !, _settings !);
}
public void Finish()
{
// ReSharper disable once PossibleNullReferenceException
_audioFile.Dispose();
_audioFile = null;
// ReSharper disable once PossibleNullReferenceException
_stream.Position = 0;
// Call the external MP4 encoder for writing iTunes-compatible atoms
var metadataEncoderFactory =
ExtensionProvider.GetFactories <IAudioMetadataEncoder>("Extension", FileExtension).FirstOrDefault();
if (metadataEncoderFactory == null)
{
return;
}
using (var export = metadataEncoderFactory.CreateExport())
// ReSharper disable twice AssignNullToNotNullAttribute
export.Value.WriteMetadata(_stream, _metadata, _settings);
}
public void Submit(SampleCollection samples)
{
Contract.Ensures(_buffer != null);
if (_buffer == null)
{
_buffer = new int[samples.SampleCount * samples.Channels];
}
if (!samples.IsLast)
{
var index = 0;
for (var sample = 0; sample < samples.SampleCount; sample++)
{
for (var channel = 0; channel < samples.Channels; channel++)
{
_buffer[index++] = (int)Math.Round(samples[channel][sample] * _multiplier);
}
}
GCHandle handle = GCHandle.Alloc(_buffer, GCHandleType.Pinned);
try
{
var bufferList = new AudioBufferList
{
NumberBuffers = 1,
Buffers = new AudioBuffer[1]
};
bufferList.Buffers[0].NumberChannels = (uint)samples.Channels;
bufferList.Buffers[0].DataByteSize = (uint)(index * Marshal.SizeOf <int>());
bufferList.Buffers[0].Data = handle.AddrOfPinnedObject();
ExtendedAudioFileStatus status = _audioFile.Write(bufferList, (uint)samples.SampleCount);
if (status != ExtendedAudioFileStatus.Ok)
{
throw new IOException(string.Format(CultureInfo.CurrentCulture,
Resources.SampleEncoderWriteError, status));
}
}
finally
{
handle.Free();
}
}
else
{
_audioFile.Dispose();
// Call an external MP4 encoder for writing iTunes-compatible atoms:
_stream.Position = 0;
ExportFactory <IMetadataEncoder> metadataEncoderFactory =
ExtensionProvider.GetFactories <IMetadataEncoder>("Extension", EncoderInfo.FileExtension)
.SingleOrDefault();
if (metadataEncoderFactory == null)
{
throw new ExtensionInitializationException(string.Format(CultureInfo.CurrentCulture,
Resources.SampleEncoderMetadataEncoderError, EncoderInfo.FileExtension));
}
using (ExportLifetimeContext <IMetadataEncoder> metadataEncoderLifetime = metadataEncoderFactory.CreateExport())
metadataEncoderLifetime.Value.WriteMetadata(_stream, _metadata, _settings);
}
}
internal static IEnumerable <ExportFactory <T> > GetFactories <T>([NotNull] string key, [NotNull] string value)
where T : class
{
return(ExtensionProvider.GetFactories <T>(key, value));
}
internal static IEnumerable <ExportFactory <T, IDictionary <string, object> > > GetFactories <T>()
where T : class
{
return(ExtensionProvider.GetFactories <T>());
}
internal static IEnumerable <ExportFactory <T> > GetFactories <T>(string key, string value)
where T : class =>
ExtensionProvider.GetFactories <T>(key, value);
public void Initialize(Stream stream, AudioInfo audioInfo, MetadataDictionary metadata, SettingsDictionary settings)
{
Contract.Ensures(_stream != null);
Contract.Ensures(_stream == stream);
Contract.Ensures(_metadata != null);
Contract.Ensures(_metadata == metadata);
Contract.Ensures(_settings != null);
Contract.Ensures(_settings == settings);
Contract.Ensures(_audioFile != null);
_stream = stream;
_metadata = metadata;
_settings = settings;
// Load the external gain filter:
ExportFactory <ISampleFilter> sampleFilterFactory =
ExtensionProvider.GetFactories <ISampleFilter>("Name", "ReplayGain").SingleOrDefault();
if (sampleFilterFactory == null)
{
throw new ExtensionInitializationException(Resources.AacSampleEncoderReplayGainFilterError);
}
_replayGainFilterLifetime = sampleFilterFactory.CreateExport();
_replayGainFilterLifetime.Value.Initialize(metadata, settings);
AudioStreamBasicDescription inputDescription = GetInputDescription(audioInfo);
AudioStreamBasicDescription outputDescription = GetOutputDescription(inputDescription);
try
{
_audioFile = new NativeExtendedAudioFile(outputDescription, AudioFileType.M4A, stream);
ExtendedAudioFileStatus status = _audioFile.SetProperty(ExtendedAudioFilePropertyId.ClientDataFormat,
inputDescription);
if (status != ExtendedAudioFileStatus.Ok)
{
throw new IOException(string.Format(CultureInfo.CurrentCulture,
Resources.SampleEncoderInitializationError, status));
}
// Configure the audio converter:
ConfigureConverter(settings, audioInfo.Channels,
_audioFile.GetProperty <IntPtr>(ExtendedAudioFilePropertyId.AudioConverter));
// Setting the ConverterConfig property to null resynchronizes the converter settings:
ExtendedAudioFileStatus fileStatus = _audioFile.SetProperty(
ExtendedAudioFilePropertyId.ConverterConfig, IntPtr.Zero);
if (fileStatus != ExtendedAudioFileStatus.Ok)
{
throw new IOException(string.Format(CultureInfo.CurrentCulture,
Resources.SampleEncoderConverterError, status));
}
}
catch (TypeInitializationException e)
{
if (e.InnerException != null && e.InnerException.GetType() == typeof(ExtensionInitializationException))
{
throw e.InnerException;
}
throw;
}
}
