/// <summary>
/// Saves the metadata, using an available <see cref="IMetadataEncoder"/>. If no extensions are able to write
/// to this file extension, an <see cref="UnsupportedAudioException"/>
/// </summary>
/// <param name="settings">The settings.</param>
/// <exception cref="UnsupportedAudioException">
/// No metadata encoders are able to save metadata in the required format.
/// </exception>
public void SaveMetadata(SettingsDictionary settings = null)
{
if (settings == null)
{
settings = new SettingsDictionary();
}
using (FileStream fileStream = FileInfo.Open(FileMode.Open, FileAccess.ReadWrite))
{
// Ensure the existing metadata has been loaded:
if (_metadata == null)
{
LoadMetadata(fileStream);
fileStream.Position = 0;
}
// Try each encoder that supports the file extension:
foreach (ExportFactory <IMetadataEncoder> encoderFactory in
ExtensionProvider.GetFactories <IMetadataEncoder>("Extension", FileInfo.Extension))
{
using (ExportLifetimeContext <IMetadataEncoder> lifetimeContext = encoderFactory.CreateExport())
{
IMetadataEncoder encoder = lifetimeContext.Value;
ValidateSettings(settings, encoder);
encoder.WriteMetadata(fileStream, Metadata, settings);
return;
}
}
}
throw new UnsupportedAudioException(Resources.TaggedAudioFileUnsupportedError);
}
public static void WriteMetadata(this IMetadataEncoder encoder, IBufferWriter <byte> writer, Frame frame)
{
var metaLength = encoder.GetLength(frame.Metadata);
var metaSpan = writer.GetSpan(metaLength);
encoder.Write(metaSpan, frame.Metadata);
writer.Advance(metaLength);
}
static void ValidateSettings(SettingsDictionary settings, IMetadataEncoder encoder)
{
Contract.Requires(settings != null);
Contract.Requires(encoder != null);
foreach (string unsupportedKey in settings.Keys.Where(setting =>
!encoder.EncoderInfo.AvailableSettings.Contains(setting, StringComparer.OrdinalIgnoreCase)))
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,
Resources.TaggedAudioFileSettingsError, unsupportedKey));
}
}
public PooledFrameEncoderPolicy(IMetadataEncoder metaEncoder) => _metaEncoder = metaEncoder;
public PooledMessageEncoderPolicy(IMetadataEncoder metaEncoder, IMessageWriter writer)
{
_metaEncoder = metaEncoder;
_writer = writer;
}
protected MessageAsFrameWriter(IMetadataEncoder metaEncoder) =>
public MessageEncoderFactory(IMetadataEncoder metaEncoder, IMessageWriter msgWriter)
{
_metaEncoder = metaEncoder;
_msgWriter = msgWriter;
}
public MessageWriter(IMetadataEncoder metaEncoder) : base(metaEncoder)
{
}
public PooledMessageEncoder(IMessageWriter messageWriter, IMetadataEncoder metadataEncoder)
: base(messageWriter, metadataEncoder, default)
{
}
public static ValueTask <FlushResult> WriteFrameAsync(this IMetadataEncoder encoder, PipeWriter writer, Frame frame, CancellationToken token = default)
{
encoder.WriteMetadata(writer, frame);
return(writer.WriteByChunkAsync(frame.Payload, token));
}
public static IFrameEncoder AsFrameEncoder(this IMetadataEncoder encoder, PipeWriter writer,
CancellationToken token = default) => new PipeFrameEncoder(encoder, writer, token);
public PipeMessageEncoder(IMessageWriter messageWriter, IMetadataEncoder metadataEncoder, PipeWriter writer,
CancellationToken token = default) : base(metadataEncoder, writer, token) =>
public DefaultEncoderFactory(IMetadataEncoder encoder) => _encoder = encoder;
public PooledFrameEncoder(IMetadataEncoder metadataEncoder)
: base(metadataEncoder, default)
{
}
