/// <summary>
/// Writes the chunk object <paramref name="instance"/> to the stream.
/// </summary>
/// <param name="context">Must not be null.</param>
/// <param name="instance">Must not be null.</param>
public override void Write(ChunkFileContext context, object instance)
{
Check.IfArgumentNull(context, nameof(context));
Check.IfArgumentNull(instance, nameof(instance));
Check.IfArgumentNotOfType <MTrkChunk>(instance, nameof(instance));
var trackChunk = (MTrkChunk)instance;
var writer = context.Services.GetService <FileChunkWriter>();
var stream = writer.CurrentStream;
var midiWriter = new MidiFileStreamWriter(stream);
foreach (var message in trackChunk.Events)
{
if (message.Message is MidiShortMessage shortMessage)
{
midiWriter.WriteMidiEvent(message.DeltaTime, shortMessage.Data);
}
else
{
if (message.Message is MidiMetaMessage metaMsg)
{
midiWriter.WriteMetaEvent(message.DeltaTime, metaMsg.MetaType, metaMsg.GetData());
}
if (message.Message is MidiSysExMessage sysexMsg)
{
midiWriter.WriteSysExEvent(message.DeltaTime, sysexMsg.GetData(), sysexMsg.IsContinuation);
}
}
}
}
public override void Write(ChunkFileContext context, object instance)
{
Check.IfArgumentNull(context, "context");
Check.IfArgumentNull(instance, "instance");
Check.IfArgumentNotOfType <MTrkChunk>(instance, "instance");
var trackChunk = (MTrkChunk)instance;
var writer = context.CompositionContainer.GetService <FileChunkWriter>();
var stream = writer.CurrentStream;
var midiWriter = new MidiFileStreamWriter(stream);
foreach (var message in trackChunk.Events)
{
if (message.Message is MidiShortMessage)
{
midiWriter.WriteMidiEvent(message.DeltaTime, ((MidiShortMessage)message.Message).Data);
}
else
{
var metaMsg = message.Message as MidiMetaMessage;
var sysexMsg = message.Message as MidiSysExMessage;
if (metaMsg != null)
{
midiWriter.WriteMetaEvent(message.DeltaTime, metaMsg.MetaType, metaMsg.GetData());
}
if (sysexMsg != null)
{
midiWriter.WriteSysExEvent(message.DeltaTime, sysexMsg.GetData(), sysexMsg.IsContinuation);
}
}
}
}
public override void Write(ChunkFileContext context, object instance)
{
Check.IfArgumentNull(context, "context");
Check.IfArgumentNull(instance, "instance");
Check.IfArgumentNotOfType <ListChunk>(instance, "instance");
var listChunk = (ListChunk)instance;
if (listChunk.InnerChunks == null)
{
throw new ArgumentException("No LIST content found.", "instance");
}
listChunk.ItemType = new FourCharacterCode(GetCollectionItemChunkId(listChunk.InnerChunks));
// write out LIST chunk
base.Write(context, instance);
var writer = context.CompositionContainer.GetService <FileChunkWriter>();
foreach (var item in listChunk.InnerChunks)
{
writer.WriteRuntimeChunkType(item);
}
}
public override object Read(ChunkFileContext context)
{
// create instance and read type
var riffChunk = base.Read(context) as RiffChunk;
if (riffChunk == null)
{
throw new InvalidOperationException();
}
// read child chunk of 'type'
var reader = context.CompositionContainer.GetService <FileChunkReader>();
var stream = reader.CurrentStream;
riffChunk.InnerChunk = reader.ReadRuntimeContainerChunkType(stream, riffChunk.FileType);
// the 4CC FileType was not found as a runtime chunk type.
if (riffChunk.InnerChunk == null)
{
// normally we'd skip an unknown chunk but at the root its no use.
var msg = String.Format(
CultureInfo.InvariantCulture,
"The Four Character Code '{0}' specified in the RIFF (root) chunk could not be mapped to a CLR Type.",
riffChunk.FileType);
throw new ChunkFileException(msg);
}
return(riffChunk);
}
public virtual ChunkFileContext Detach()
{
Context.Services.RemoveService(GetType());
var context = Context;
Context = null;
return(context);
}
public static ChunkFileContext CreateFileContextForReading(string filePath)
{
var context = new ChunkFileContext();
context.ChunkFile = ChunkFileInfo.OpenRead(filePath);
context.CompositionContainer = CreateCompositionContextForReading();
return(context);
}
public override object Read(ChunkFileContext context)
{
Contract.Requires(context.CompositionContainer != null);
Check.IfArgumentNull(context, "context");
Check.IfArgumentNull(context.ChunkStack, "context.ChunkStack");
Check.IfArgumentNull(context.ChunkStack.CurrentChunk, "context.ChunkStack.CurrentChunk");
Check.IfArgumentNull(context.CompositionContainer, "context.CompositionContainer");
// create instance and read type
var listChunk = base.Read(context) as ListChunk;
if (listChunk == null)
{
throw new InvalidOperationException();
}
// read child chunk of 'type'
var reader = context.CompositionContainer.GetService <FileChunkReader>();
var chunk = context.ChunkStack.CurrentChunk;
var stream = chunk.DataStream;
var itemType = LookupItemType(context, listChunk.ItemType);
IList children = null;
if (itemType != null)
{
// create a generic list with the correct item type.
var listType = typeof(List <>).MakeGenericType(new[] { itemType });
children = (IList)Activator.CreateInstance(listType);
}
// while there is still data in the stream
while (stream.Position < stream.Length)
{
var runtimeObj = reader.ReadRuntimeContainerChunkType(stream, listChunk.ItemType);
// check if CLR type could be found for 'ItemType'.
if (runtimeObj != null && children != null)
{
children.Add(runtimeObj);
}
}
if (children != null)
{
listChunk.InnerChunks = children.Cast <object>();
}
return(children);
}
/// <summary>
/// Write event data to a Midi file using a prepared chunk-file context.
/// </summary>
/// <param name="midiFile">The Midi file data to write. Must not be null.</param>
/// <param name="context">Must not be null or empty.</param>
/// <remarks>May throw exceptions.</remarks>
public static void Write(MidiFile midiFile, ChunkFileContext context)
{
Check.IfArgumentNull(midiFile, nameof(midiFile));
Check.IfArgumentNull(context, nameof(context));
var writer = new FileChunkWriter(context);
writer.WriteNextChunk(midiFile.Header);
foreach (var track in midiFile.Tracks)
{
writer.WriteNextChunk(track);
}
}
/// <summary>
/// Reads the midi track from the midi file.
/// </summary>
/// <param name="context">File context of the midi file being read. Must not be null.</param>
/// <returns>Returns the custom chunk object containing the data that was read.</returns>
public override object Read(ChunkFileContext context)
{
Check.IfArgumentNull(context, nameof(context));
var reader = context.Services.GetService <FileChunkReader>();
var stream = reader.CurrentStream;
var chunk = new MTrkChunk();
var events = new List <MidiFileEvent>();
chunk.Events = events;
var midiReader = new MidiFileStreamReader(stream);
// use the indication to copy buffers.
_midiMessageFactory.CopyData = context.CopyStreams;
while (midiReader.ReadNextEvent())
{
MidiFileEvent midiEvent = null;
switch (midiReader.EventType)
{
case MidiFileEventType.Event:
midiEvent = CreateMidiEvent(midiReader.AbsoluteTime, midiReader.DeltaTime, midiReader.MidiEvent);
break;
case MidiFileEventType.SystemExclusive:
midiEvent = CreateSysExEvent(midiReader.AbsoluteTime, midiReader.DeltaTime, midiReader.Data, false);
break;
case MidiFileEventType.SystemExclusiveContinuation:
midiEvent = CreateSysExEvent(midiReader.AbsoluteTime, midiReader.DeltaTime, midiReader.Data, true);
break;
case MidiFileEventType.Meta:
midiEvent = CreateMetaEvent(midiReader.AbsoluteTime, midiReader.DeltaTime, midiReader.MetaEvent, midiReader.Data);
break;
}
if (midiEvent != null)
{
events.Add(midiEvent);
}
}
return(chunk);
}
public static ChunkFileContext CreateFileContextForWriting(string filePath, bool littleEndian)
{
Assert.IsNotNull(filePath);
Assert.IsTrue(Directory.Exists(Path.GetDirectoryName(filePath)));
var context = new ChunkFileContext();
context.ChunkFile = ChunkFileInfo.OpenWrite(filePath);
Assert.IsNotNull(context.ChunkFile);
Assert.IsNotNull(context.ChunkFile.BaseStream);
context.CompositionContainer = CreateCompositionContext(littleEndian);
Assert.IsNotNull(context.CompositionContainer);
return(context);
}
public static ChunkFileContext CreateFileContextForReading(string filePath, bool littleEndian)
{
Assert.IsNotNull(filePath);
Assert.IsTrue(File.Exists(filePath));
var context = new ChunkFileContext();
context.ChunkFile = ChunkFileInfo.OpenRead(filePath);
Assert.IsNotNull(context.ChunkFile);
Assert.IsNotNull(context.ChunkFile.BaseStream);
context.CompositionContainer = CreateCompositionContext(littleEndian);
Assert.IsNotNull(context.CompositionContainer);
return(context);
}
/// <summary>
/// Read event data of a Midi file prepared chunk-file context.
/// </summary>
/// <param name="context">Must not be null.</param>
/// <returns>Never returns null.</returns>
/// <remarks>May throw exceptions.</remarks>
public static MidiFile Read(ChunkFileContext context)
{
Check.IfArgumentNull(context, nameof(context));
var reader = new FileChunkReader(context);
var file = new MidiFile
{
Header = reader.ReadNextChunk() as MThdChunk
};
var tracks = new List <MTrkChunk>();
for (int i = 0; i < file.Header.NumberOfTracks; i++)
{
var track = reader.ReadNextChunk() as MTrkChunk;
tracks.Add(track);
}
file.Tracks = tracks;
return(file);
}
public override void Write(ChunkFileContext context, object instance)
{
Check.IfArgumentNull(context, "context");
Check.IfArgumentNull(instance, "instance");
Check.IfArgumentNotOfType <RiffChunk>(instance, "instance");
var chunk = (RiffChunk)instance;
if (chunk.InnerChunk == null)
{
throw new ArgumentException("No RIFF chunk content found.", "instance");
}
// make sure the correct file type is set.
chunk.FileType = new FourCharacterCode(ChunkAttribute.GetChunkId(chunk.InnerChunk));
// write out RIFF file type
base.Write(context, instance);
var writer = context.CompositionContainer.GetService <FileChunkWriter>();
writer.WriteRuntimeChunkType(chunk.InnerChunk);
}
/// <summary>
/// Helper to find the runtime Type for a chunk.
/// </summary>
/// <param name="context">Must not be null.</param>
/// <param name="chunkId">Must not be null.</param>
/// <returns>Returns null when not found.</returns>
private static Type LookupItemType(ChunkFileContext context, FourCharacterCode chunkId)
{
var factory = context.CompositionContainer.GetService <IChunkTypeFactory>();
return(factory.LookupChunkObjectType(chunkId));
}
protected ChunkFileContextOwner(ChunkFileContext context)
{
Check.IfArgumentNull(context, nameof(context));
Context = context;
}
