// Token: 0x0600348C RID: 13452 RVA: 0x00018286 File Offset: 0x00016486
public static IEnumerable <TrackChunk> Explode(this TrackChunk trackChunk)
{
return(TrackChunkUtilities.ConvertTrackChunks(new TrackChunk[]
{
trackChunk
}, MidiFileFormat.MultiTrack));
}
public IEnumerable <MidiChunk> Convert(IEnumerable <MidiChunk> chunks)
{
if (chunks == null)
{
throw new ArgumentNullException(nameof(chunks));
}
//
var trackChunks = chunks.OfType <TrackChunk>().ToArray();
if (trackChunks.Length == 1)
{
return(chunks);
}
//
var eventsDescriptors = trackChunks
.SelectMany(trackChunk =>
{
var absoluteTime = 0L;
var channel = -1;
return(trackChunk.Events
.Select(midiEvent =>
{
var channelPrefixEvent = midiEvent as ChannelPrefixEvent;
if (channelPrefixEvent != null)
{
channel = channelPrefixEvent.Channel;
}
if (!(midiEvent is MetaEvent))
{
channel = -1;
}
return new EventDescriptor(midiEvent, (absoluteTime += midiEvent.DeltaTime), channel);
}));
})
.OrderBy(d => d, new EventDescriptorComparer());
//
var resultTrackChunk = new TrackChunk();
var time = 0L;
foreach (var eventDescriptor in eventsDescriptors)
{
var midiEvent = (MidiEvent)eventDescriptor.Event.Clone();
midiEvent.DeltaTime = eventDescriptor.AbsoluteTime - time;
resultTrackChunk.Events.Add(midiEvent);
time = eventDescriptor.AbsoluteTime;
}
//
return(new[] { resultTrackChunk }.Concat(chunks.Where(c => !(c is TrackChunk))));
}
private static ushort?GetSequenceNumber(TrackChunk trackChunk)
{
ThrowIfArgument.IsNull(nameof(trackChunk), trackChunk);
return(trackChunk.Events
.TakeWhile(m => m.DeltaTime == 0)
.OfType <SequenceNumberEvent>()
.FirstOrDefault()
?.Number);
}
// Token: 0x06003247 RID: 12871 RVA: 0x001474FC File Offset: 0x001456FC
private static ushort?GetSequenceNumber(TrackChunk trackChunk)
{
SequenceNumberEvent sequenceNumberEvent = trackChunk.Events.TakeWhile((MidiEvent m) => m.DeltaTime == 0L).OfType <SequenceNumberEvent>().FirstOrDefault <SequenceNumberEvent>();
if (sequenceNumberEvent == null)
{
return(null);
}
return(new ushort?(sequenceNumberEvent.Number));
}
private static ushort?GetSequenceNumber(TrackChunk trackChunk)
{
if (trackChunk == null)
{
throw new ArgumentNullException(nameof(trackChunk));
}
return(trackChunk.Events
.TakeWhile(m => m.DeltaTime == 0)
.OfType <SequenceNumberEvent>()
.FirstOrDefault()
?.Number);
}
// Token: 0x06003262 RID: 12898 RVA: 0x0014778C File Offset: 0x0014598C
public IEnumerable <MidiChunk> Convert(IEnumerable <MidiChunk> chunks)
{
TrackChunk[] array = chunks.OfType <TrackChunk>().ToArray <TrackChunk>();
if (array.Length == 1)
{
return(chunks);
}
MidiEvent midiEvent;
IEnumerable <SingleTrackChunksConverter.EventDescriptor> enumerable = array.SelectMany(delegate(TrackChunk trackChunk)
{
long absoluteTime = 0L;
int channel = -1;
return(trackChunk.Events.Select(delegate(MidiEvent midiEvent)
{
ChannelPrefixEvent channelPrefixEvent = midiEvent as ChannelPrefixEvent;
if (channelPrefixEvent != null)
{
channel = (int)channelPrefixEvent.Channel;
}
if (!(midiEvent is MetaEvent))
{
channel = -1;
}
return new SingleTrackChunksConverter.EventDescriptor(midiEvent, absoluteTime += midiEvent.DeltaTime, channel);
}));
}).OrderBy((SingleTrackChunksConverter.EventDescriptor d) => d, new SingleTrackChunksConverter.EventDescriptorComparer());
TrackChunk trackChunk2 = new TrackChunk();
long num = 0L;
foreach (SingleTrackChunksConverter.EventDescriptor eventDescriptor in enumerable)
{
midiEvent = eventDescriptor.Event.Clone();
midiEvent.DeltaTime = eventDescriptor.AbsoluteTime - num;
trackChunk2.Events.Add(midiEvent);
num = eventDescriptor.AbsoluteTime;
}
return(new TrackChunk[]
{
trackChunk2
}.Concat(from c in chunks
where !(c is TrackChunk)
select c));
}
// Token: 0x06003410 RID: 13328 RVA: 0x00148C28 File Offset: 0x00146E28
private static MidiChunk ReadChunk(MidiReader reader, ReadingSettings settings, int actualTrackChunksCount, int?expectedTrackChunksCount)
{
MidiChunk midiChunk = null;
try
{
string text = reader.ReadString(4);
if (text.Length < 4)
{
NotEnoughBytesPolicy notEnoughBytesPolicy = settings.NotEnoughBytesPolicy;
if (notEnoughBytesPolicy == NotEnoughBytesPolicy.Abort)
{
throw new NotEnoughBytesException("Chunk ID cannot be read since the reader's underlying stream doesn't have enough bytes.", 4L, (long)text.Length);
}
if (notEnoughBytesPolicy == NotEnoughBytesPolicy.Ignore)
{
return(null);
}
}
if (!(text == "MThd"))
{
if (!(text == "MTrk"))
{
midiChunk = MidiFile.TryCreateChunk(text, settings.CustomChunkTypes);
}
else
{
midiChunk = new TrackChunk();
}
}
else
{
midiChunk = new HeaderChunk();
}
if (midiChunk == null)
{
switch (settings.UnknownChunkIdPolicy)
{
case UnknownChunkIdPolicy.ReadAsUnknownChunk:
midiChunk = new UnknownChunk(text);
break;
case UnknownChunkIdPolicy.Skip:
{
uint num = reader.ReadDword();
reader.Position += (long)((ulong)num);
return(null);
}
case UnknownChunkIdPolicy.Abort:
throw new UnknownChunkException("'" + text + "' chunk ID is unknown.", text);
}
}
if (midiChunk is TrackChunk && expectedTrackChunksCount != null)
{
int?num2 = expectedTrackChunksCount;
if (actualTrackChunksCount >= num2.GetValueOrDefault() & num2 != null)
{
MidiFile.ReactOnUnexpectedTrackChunksCount(settings.UnexpectedTrackChunksCountPolicy, actualTrackChunksCount, expectedTrackChunksCount.Value);
ExtraTrackChunkPolicy extraTrackChunkPolicy = settings.ExtraTrackChunkPolicy;
if (extraTrackChunkPolicy != ExtraTrackChunkPolicy.Read && extraTrackChunkPolicy == ExtraTrackChunkPolicy.Skip)
{
uint num3 = reader.ReadDword();
reader.Position += (long)((ulong)num3);
return(null);
}
}
}
midiChunk.Read(reader, settings);
}
catch (NotEnoughBytesException exception)
{
MidiFile.ReactOnNotEnoughBytes(settings.NotEnoughBytesPolicy, exception);
}
catch (EndOfStreamException exception2)
{
MidiFile.ReactOnNotEnoughBytes(settings.NotEnoughBytesPolicy, exception2);
}
return(midiChunk);
}
/// <summary>
/// Reads a chunk from a MIDI-file.
/// </summary>
/// <param name="reader">Reader to read a chunk with.</param>
/// <param name="settings">Settings according to which a chunk must be read.</param>
/// <param name="actualTrackChunksCount">Actual count of track chunks at the moment.</param>
/// <param name="expectedTrackChunksCount">Expected count of track chunks.</param>
/// <returns>A MIDI-file chunk.</returns>
/// <exception cref="ObjectDisposedException">Method was called after the reader was disposed.</exception>
/// <exception cref="IOException">An I/O error occurred on the underlying stream.</exception>
/// <exception cref="UnknownChunkException">Chunk to be read has unknown ID and that
/// should be treated as error accordng to the specified <paramref name="settings"/>.</exception>
/// <exception cref="UnexpectedTrackChunksCountException">Actual track chunks
/// count is greater than expected one and that should be treated as error according to
/// the specified <paramref name="settings"/>.</exception>
/// <exception cref="InvalidChunkSizeException">Actual chunk's size differs from the one declared
/// in its header and that should be treated as error according to the specified
/// <paramref name="settings"/>.</exception>
/// <exception cref="UnknownChannelEventException">Reader has encountered an unknown channel event.</exception>
/// <exception cref="NotEnoughBytesException">Value cannot be read since the reader's underlying stream
/// doesn't have enough bytes.</exception>
/// <exception cref="UnexpectedRunningStatusException">Unexpected running status is encountered.</exception>
/// <exception cref="MissedEndOfTrackEventException">Track chunk doesn't end with End Of Track event and that
/// should be treated as error accordng to the specified <paramref name="settings"/>.</exception>
/// <exception cref="InvalidChannelEventParameterValueException">Value of a channel event's parameter
/// just read is invalid.</exception>
/// <exception cref="InvalidMetaEventParameterValueException">Value of a meta event's parameter
/// just read is invalid.</exception>
private static MidiChunk ReadChunk(MidiReader reader, ReadingSettings settings, int actualTrackChunksCount, int?expectedTrackChunksCount)
{
MidiChunk chunk = null;
try
{
var chunkId = reader.ReadString(MidiChunk.IdLength);
if (chunkId.Length < MidiChunk.IdLength)
{
switch (settings.NotEnoughBytesPolicy)
{
case NotEnoughBytesPolicy.Abort:
throw new NotEnoughBytesException("Chunk ID cannot be read since the reader's underlying stream doesn't have enough bytes.",
MidiChunk.IdLength,
chunkId.Length);
case NotEnoughBytesPolicy.Ignore:
return(null);
}
}
//
switch (chunkId)
{
case HeaderChunk.Id:
chunk = new HeaderChunk();
break;
case TrackChunk.Id:
chunk = new TrackChunk();
break;
default:
chunk = TryCreateChunk(chunkId, settings.CustomChunkTypes);
break;
}
//
if (chunk == null)
{
switch (settings.UnknownChunkIdPolicy)
{
case UnknownChunkIdPolicy.ReadAsUnknownChunk:
chunk = new UnknownChunk(chunkId);
break;
case UnknownChunkIdPolicy.Skip:
var size = reader.ReadDword();
reader.Position += size;
return(null);
case UnknownChunkIdPolicy.Abort:
throw new UnknownChunkException($"'{chunkId}' chunk ID is unknown.", chunkId);
}
}
//
if (chunk is TrackChunk && expectedTrackChunksCount != null && actualTrackChunksCount >= expectedTrackChunksCount)
{
ReactOnUnexpectedTrackChunksCount(settings.UnexpectedTrackChunksCountPolicy, actualTrackChunksCount, expectedTrackChunksCount.Value);
switch (settings.ExtraTrackChunkPolicy)
{
case ExtraTrackChunkPolicy.Read:
break;
case ExtraTrackChunkPolicy.Skip:
var size = reader.ReadDword();
reader.Position += size;
return(null);
}
}
//
chunk.Read(reader, settings);
}
catch (NotEnoughBytesException ex)
{
ReactOnNotEnoughBytes(settings.NotEnoughBytesPolicy, ex);
}
catch (EndOfStreamException ex)
{
ReactOnNotEnoughBytes(settings.NotEnoughBytesPolicy, ex);
}
return(chunk);
}
/// <summary>
/// Splits a track chunk into multiple ones that correspond to <see cref="MidiFileFormat.MultiTrack"/>.
/// </summary>
/// <param name="trackChunk">Track chunk to split into multiple ones.</param>
/// <returns>Multiple track chunks that represent <paramref name="trackChunk"/>.</returns>
/// <remarks>
/// Note that events will be cloned so events in the result track chunks will not be equal
/// by reference to events in the <paramref name="trackChunk"/>.
/// </remarks>
/// <exception cref="ArgumentNullException"><paramref name="trackChunk"/> is null.</exception>
public static IEnumerable <TrackChunk> Explode(this TrackChunk trackChunk)
{
ThrowIfArgument.IsNull(nameof(trackChunk), trackChunk);
return(ConvertTrackChunks(new[] { trackChunk }, MidiFileFormat.MultiTrack));
}
/// <summary>
/// Gets all channel numbers presented in the specified <see cref="TrackChunk"/>.
/// </summary>
/// <param name="trackChunk"><see cref="TrackChunk"/> to get channels of.</param>
/// <returns>Collection of channel numbers presented in the <paramref name="trackChunk"/>.</returns>
/// <exception cref="ArgumentNullException"><paramref name="trackChunk"/> is null.</exception>
public static IEnumerable <FourBitNumber> GetChannels(this TrackChunk trackChunk)
{
ThrowIfArgument.IsNull(nameof(trackChunk), trackChunk);
return(trackChunk.Events.OfType <ChannelEvent>().Select(e => e.Channel).Distinct().ToArray());
}
// Token: 0x06003234 RID: 12852 RVA: 0x001470DC File Offset: 0x001452DC
private void ProcessEvents(WritingSettings settings, Action <IEventWriter, MidiEvent, bool> eventHandler)
{
byte?b = null;
bool flag = true;
bool flag2 = true;
bool flag3 = true;
foreach (MidiEvent midiEvent in this.Events.Concat(new EndOfTrackEvent[]
{
new EndOfTrackEvent()
}))
{
if (!(midiEvent is UnknownMetaEvent) || !settings.CompressionPolicy.HasFlag(CompressionPolicy.DeleteUnknownMetaEvents))
{
if (settings.CompressionPolicy.HasFlag(CompressionPolicy.NoteOffAsSilentNoteOn))
{
NoteOffEvent noteOffEvent = midiEvent as NoteOffEvent;
if (noteOffEvent != null)
{
midiEvent = new NoteOnEvent
{
DeltaTime = noteOffEvent.DeltaTime,
Channel = noteOffEvent.Channel,
NoteNumber = noteOffEvent.NoteNumber
};
}
}
if ((!settings.CompressionPolicy.HasFlag(CompressionPolicy.DeleteDefaultSetTempo) || !TrackChunk.TrySkipDefaultSetTempo(midiEvent, ref flag)) && (!settings.CompressionPolicy.HasFlag(CompressionPolicy.DeleteDefaultKeySignature) || !TrackChunk.TrySkipDefaultKeySignature(midiEvent, ref flag2)) && (!settings.CompressionPolicy.HasFlag(CompressionPolicy.DeleteDefaultTimeSignature) || !TrackChunk.TrySkipDefaultTimeSignature(midiEvent, ref flag3)))
{
IEventWriter writer = EventWriterFactory.GetWriter(midiEvent);
bool arg;
if (midiEvent is ChannelEvent)
{
byte statusByte = writer.GetStatusByte(midiEvent);
byte?b2 = b;
int? num = (b2 != null) ? new int?((int)b2.GetValueOrDefault()) : null;
int num2 = (int)statusByte;
arg = (!(num.GetValueOrDefault() == num2 & num != null) || !settings.CompressionPolicy.HasFlag(CompressionPolicy.UseRunningStatus));
b = new byte?(statusByte);
}
else
{
b = null;
arg = true;
}
eventHandler(writer, midiEvent, arg);
}
}
}
}