public void Write_DeleteDefaultSetTempo()
{
var nonDefaultSetTempoEvent = new SetTempoEvent(100000);
var midiFile = new MidiFile(
new TrackChunk(
new NoteOnEvent((SevenBitNumber)100, (SevenBitNumber)50),
new NoteOffEvent((SevenBitNumber)100, (SevenBitNumber)50),
new UnknownMetaEvent(254),
new SetTempoEvent(),
nonDefaultSetTempoEvent));
Write(
midiFile,
settings => settings.DeleteDefaultSetTempo = true,
(fileInfo1, fileInfo2) =>
{
var originalMidiFile = MidiFile.Read(fileInfo1.FullName);
Assert.AreEqual(
2,
originalMidiFile.GetTrackChunks().SelectMany(c => c.Events).OfType <SetTempoEvent>().Count(),
"Invalid count of Set Tempo events in original file.");
var newMidiFile = MidiFile.Read(fileInfo2.FullName);
var setTempoEvents = newMidiFile.GetTrackChunks().SelectMany(c => c.Events).OfType <SetTempoEvent>().ToArray();
Assert.AreEqual(
1,
setTempoEvents.Length,
"Invalid count of Set Tempo events in new file.");
MidiAsserts.AreEventsEqual(setTempoEvents[0], nonDefaultSetTempoEvent, false, "Invalid Set Tempo event.");
});
}
public List <MidiEvent> PopEvents(SetTempoEvent lastTempoEvent)
{
var res = new List <MidiEvent>();
var nextTime = Time + SecondsPerPop;
bool add = true;
while (eventIndex + 1 < events.Count && add)
{
add = false;
var e = events[eventIndex + 1];
var sampleTime = lastSampleTime + Helpers.TimeConverter.CalculateDeltaSeconds(e, lastTempoEvent.MicrosecondsPerQuarterNote, TimeDivision.TicksPerQuarterNote);
if (sampleTime <= nextTime)
{
add = true;
res.Add(e);
eventIndex++;
lastSampleTime = sampleTime;
}
}
if (eventIndex + 1 >= events.Count)
{
IsFinished = true;
}
Time = nextTime;
return(res);
}
// Token: 0x06002A63 RID: 10851 RVA: 0x001380BC File Offset: 0x001362BC
private static void smethod_5(EventsCollection eventsCollection_0, Song gclass27_0)
{
if (!GClass30.bool_0)
{
foreach (MidiEvent midiEvent in eventsCollection_0)
{
TimeSignatureEvent timeSignatureEvent = midiEvent as TimeSignatureEvent;
if (timeSignatureEvent != null)
{
long absoluteTime = midiEvent.AbsoluteTime;
gclass27_0.method_39(new GClass25((uint)absoluteTime, (uint)timeSignatureEvent.Numerator, (uint)timeSignatureEvent.Denominator), false);
}
else
{
SetTempoEvent setTempoEvent = midiEvent as SetTempoEvent;
if (setTempoEvent != null)
{
long absoluteTime2 = midiEvent.AbsoluteTime;
gclass27_0.method_39(new GClass24((uint)absoluteTime2, (uint)(60000000.0 / (double)setTempoEvent.MicrosecondsPerQuarterNote * 1000.0)), false);
}
else
{
TextEvent textEvent = midiEvent as TextEvent;
if (textEvent != null)
{
gclass27_0.string_0 = textEvent.Text;
}
}
}
}
gclass27_0.method_15();
}
}
public void AddTempo(uint tempo)
{
var n = new SetTempoEvent(tempo);
var e = new EventData();
e.EventType = EventTypeList.Tempo;
e.Event = n;
e.DeltaTime = 0;
Events.Add(e);
}
private static TrackChunk AddSetTempoEvents(TrackChunk chunkito, List <TempoChange> tc)
{
foreach (var t in tc)
{
var setTempoEvent = new SetTempoEvent()
{
DeltaTime = t.TicksSinceBeginningOfSong,
MicrosecondsPerQuarterNote = t.MicrosecondsPerQuarterNote
};
chunkito.Events.Add(setTempoEvent);
}
return(chunkito);
}
public void PreProcessTempoMap()
{
foreach (var trackChunk in trunks)
{
using (var eventsManager = trackChunk.Events.ManageTimedEvents())
{
foreach (var tmpChange in Tmap.Tempo)
{
var ev = new SetTempoEvent(tmpChange.Value.MicrosecondsPerQuarterNote);
eventsManager.Events.AddEvent(ev, tmpChange.Time);
}
}
}
}
public void NextSample()
{
var lastTempo = tempos[tempoIndex];
var nextTime = Time + SecondsPerPop;
while (tempoIndex + 1 < tempos.Count)
{
var tempo = tempos[tempoIndex + 1];
var tempoTime = Helpers.TimeConverter.CalculateDeltaSeconds(tempo, lastTempo.MicrosecondsPerQuarterNote, TimeDivision.TicksPerQuarterNote);
if (tempoTime <= nextTime)
{
lastTempo = tempo;
CurrentTempo = tempo;
tempoIndex++;
}
else
{
break;
}
}
Time = nextTime;
}
public void Extractor()
{
int pan = 0;
int noteLength = 0;
int restLength = 0;
int tempLength = 0;
int totalLength = 0; //the sum of noteLength and restLength.
int trackVolume = 1; //volume of the MIDI track, can change throughout the track
int velocity = 0; // velocity of the MIDI note
int note = -1; //stores the value of the next note; -1 is the starting note and is a "rest" that might print only in the beginning;
bool flagNote = false;
int[] MIDILength = new int[] { 0, 0, 0, 0 };
//checks if the out.asm file already exists and clears its contents
if (File.Exists(string.Concat(directoryPath, ASMFileName, ".asm")))
{
FileStream fileStream = File.Open(string.Concat(directoryPath, ASMFileName, ".asm"), FileMode.Open);
fileStream.SetLength(0);
fileStream.Close();
}
var midifile = MidiFile.Read(directoryPath + midiFileName + "." + midiFileExtension);
var trackChuncks = midifile.GetTrackChunks(); // contains the information for all tracks
if (TempoTrack)
{
NumberOfTracks = trackChuncks.Count() - 1;
TrackNumber = -1;
}
else
{
NumberOfTracks = trackChuncks.Count();
}
//finds the TimeDivision and the number of tracks of the MIDI file
string[] tempDivision = midifile.TimeDivision.ToString().Split(' ');
TimeDivision = Int32.Parse(tempDivision[0]);
for (int k = 0; k < allowedNotetypes.Length; k++)
{
unitaryLengthArray[k] = Convert.ToInt32((double)TimeDivision / (48 / allowedNotetypes[k]));
}
unitaryLength = unitaryLengthArray[BaseNotetypeLocation];
AllTrackList = new List <MIDINote> [NumberOfTracks]; //creates the AllTrackList with NumberOfTracks Length
// Reads each track in sequence
foreach (var track in trackChuncks)
{
TrackNumber++;
trackVolume = 1; //resets trackvolume for the new track
//loops through events
foreach (MidiEvent Level2 in track.Events)
{
//get the Delta Time of the event
tempLength = (int)Level2.DeltaTime;
totalLength = noteLength + tempLength + restLength;
switch (Level2.EventType.ToString())
{
case "ControlChange":
{
ControlChangeEvent TempEvent = (ControlChangeEvent)Level2;
//tests and changes stereopanning
if (TempEvent.ControlNumber == 10)
{
pan = TempEvent.ControlValue;
}
//sets new trackvolume to define the intensity of this track. Can vary multiple times during the same music.
if (TempEvent.ControlNumber == 7)
{
trackVolume = TempEvent.ControlValue;
}
break;
}
//only relevant for the first track
case "TimeSignature":
{
TimeSignatureEvent TempEvent = (TimeSignatureEvent)Level2;
timeSignature = TempEvent.Numerator * 16 / TempEvent.Denominator;
break;
}
case "SetTempo":
{
SetTempoEvent TempEvent = (SetTempoEvent)Level2;
Tempo = Convert.ToInt32(TempEvent.MicrosecondsPerQuarterNote) / 3138;;
break;
}
case "NoteOn":
{
//register the currently "saved" note
// we are on a rest
NoteEvent TempEvent = (NoteEvent)Level2;
flagNote = true;
restLength += tempLength;
if ((restLength >= unitaryLength & TrackNumber != 4) || (restLength >= unitaryLength * 16)) //the noise channel only prints rests if its bigger than 16 times the UL
{
if (IgnoreRests)
{
NoteListTemp.Add(new MIDINote(noteLength + restLength, MIDILength[TrackNumber - 1], note, pan, velocity, trackVolume));
}
else
{
NoteListTemp.Add(new MIDINote(noteLength, MIDILength[TrackNumber - 1], note, pan, velocity, trackVolume));
NoteListTemp.Add(new MIDINote(restLength, MIDILength[TrackNumber - 1] + noteLength, 0, pan, velocity, trackVolume));
}
}
else
{
NoteListTemp.Add(new MIDINote(totalLength, MIDILength[TrackNumber - 1], note, pan, velocity, trackVolume));
}
//i++; //debug
//NoteListTemp.ElementAt(i-1).ShowNotes(); //debug
MIDILength[TrackNumber - 1] += totalLength;
noteLength = restLength = tempLength = totalLength = 0;
//setup for the next note
note = TempEvent.NoteNumber;
velocity = TempEvent.Velocity;
break;
}
case "NoteOff":
{
//NoteEvent TempEvent = (NoteEvent)Level2;
flagNote = true;
noteLength += tempLength;
break;
}
default:
{
break;
}
}
if (!flagNote & tempLength > unitaryLength)
{
restLength += tempLength;
}
else if (!flagNote)
{
noteLength += tempLength;
}
flagNote = false;
}
//last note print
if (TrackNumber > 0)
{
NoteListTemp.Add(new MIDINote(totalLength, MIDILength[TrackNumber - 1], note, pan, velocity, trackVolume));
}
//We've reached the end of the track
noteLength = restLength = totalLength = 0;
note = -1;
if (TrackNumber > 0)
{
AllTrackList[TrackNumber - 1] = new List <MIDINote>(NoteListTemp);
//for(int i=0;i<NoteListTemp.Count;i++)
//{
// Console.WriteLine(NoteListTemp.ElementAt(i));
//}
NoteListTemp.Clear();
}
}
}
private static Tuple <Option <MidiEvent>, int, byte> NextEvent(List <byte> trackData, int startIndex, byte lastMidiChannel)
{
var i = startIndex - 1;
MidiEvent midiEvent = null;
{
int deltaTime;
{
var lengthTemp = new List <byte>();
do
{
i += 1;
lengthTemp.Add(trackData.ElementAt(i));
} while (trackData.ElementAt(i) > 0x7F);
deltaTime = VariableLengthUtil.decode_to_int(lengthTemp);
}
i += 1;
var eventTypeValue = trackData.ElementAt(i);
// MIDI Channel Events
if ((eventTypeValue & 0xF0) < 0xF0)
{
var midiChannelEventType = (byte)(eventTypeValue & 0xF0);
var midiChannel = (byte)(eventTypeValue & 0x0F);
i += 1;
var parameter1 = trackData.ElementAt(i);
byte parameter2;
// One or two parameter type
switch (midiChannelEventType)
{
// One parameter types
case 0xC0:
midiEvent = new ProgramChangeEvent(deltaTime, midiChannel, parameter1);
lastMidiChannel = midiChannel;
break;
case 0xD0:
midiEvent = new ChannelAftertouchEvent(deltaTime, midiChannel, parameter1);
lastMidiChannel = midiChannel;
break;
// Two parameter types
case 0x80:
i += 1;
parameter2 = trackData.ElementAt(i);
midiEvent = new NoteOffEvent(deltaTime, midiChannel, parameter1, parameter2);
lastMidiChannel = midiChannel;
break;
case 0x90:
i += 1;
parameter2 = trackData.ElementAt(i);
midiEvent = new NoteOnEvent(deltaTime, midiChannel, parameter1, parameter2);
lastMidiChannel = midiChannel;
break;
case 0xA0:
i += 1;
parameter2 = trackData.ElementAt(i);
midiEvent = new NoteAftertouchEvent(deltaTime, midiChannel, parameter1, parameter2);
lastMidiChannel = midiChannel;
break;
case 0xB0:
i += 1;
parameter2 = trackData.ElementAt(i);
midiEvent = new ControllerEvent(deltaTime, midiChannel, parameter1, parameter2);
lastMidiChannel = midiChannel;
break;
case 0xE0:
i += 1;
parameter2 = trackData.ElementAt(i);
midiEvent = new PitchBendEvent(deltaTime, midiChannel, parameter1, parameter2);
lastMidiChannel = midiChannel;
break;
// Might be a Control Change Messages LSB
default:
midiEvent = new ControllerEvent(deltaTime, lastMidiChannel, eventTypeValue, parameter1);
break;
}
i += 1;
}
// Meta Events
else if (eventTypeValue == 0xFF)
{
i += 1;
var metaEventType = trackData.ElementAt(i);
i += 1;
var metaEventLength = trackData.ElementAt(i);
i += 1;
var metaEventData = Enumerable.Range(i, metaEventLength).Select(trackData.ElementAt).ToArray();
switch (metaEventType)
{
case 0x00:
midiEvent = new SequenceNumberEvent(BitConverter.ToUInt16(metaEventData.Reverse().ToArray(), 0));
break;
case 0x01:
midiEvent = new TextEvent(deltaTime, StringEncoder.GetString(metaEventData));
break;
case 0x02:
midiEvent = new CopyrightNoticeEvent(StringEncoder.GetString(metaEventData));
break;
case 0x03:
midiEvent = new SequenceOrTrackNameEvent(StringEncoder.GetString(metaEventData));
break;
case 0x04:
midiEvent = new InstrumentNameEvent(deltaTime, StringEncoder.GetString(metaEventData));
break;
case 0x05:
midiEvent = new LyricsEvent(deltaTime, StringEncoder.GetString(metaEventData));
break;
case 0x06:
midiEvent = new MarkerEvent(deltaTime, StringEncoder.GetString(metaEventData));
break;
case 0x07:
midiEvent = new CuePointEvent(deltaTime, StringEncoder.GetString(metaEventData));
break;
case 0x20:
midiEvent = new MIDIChannelPrefixEvent(deltaTime, metaEventData[0]);
break;
case 0x2F:
midiEvent = new EndOfTrackEvent(deltaTime);
break;
case 0x51:
var tempo =
(metaEventData[2] & 0x0F) +
((metaEventData[2] & 0xF0) * 16) +
((metaEventData[1] & 0x0F) * 256) +
((metaEventData[1] & 0xF0) * 4096) +
((metaEventData[0] & 0x0F) * 65536) +
((metaEventData[0] & 0xF0) * 1048576);
midiEvent = new SetTempoEvent(deltaTime, tempo);
break;
case 0x54:
midiEvent = new SMPTEOffsetEvent(deltaTime, metaEventData[0], metaEventData[1], metaEventData[2], metaEventData[3], metaEventData[4]);
break;
case 0x58:
midiEvent = new TimeSignatureEvent(deltaTime, metaEventData[0], metaEventData[1], metaEventData[2], metaEventData[3]);
break;
case 0x59:
midiEvent = new KeySignatureEvent(deltaTime, metaEventData[0], metaEventData[1]);
break;
case 0x7F:
midiEvent = new SequencerSpecificEvent(deltaTime, metaEventData);
break;
}
i += metaEventLength;
}
// System Exclusive Events
else if (eventTypeValue == 0xF0 || eventTypeValue == 0xF7)
{
var lengthTemp = new List <byte>();
do
{
i += 1;
lengthTemp.Add(trackData.ElementAt(i));
} while (trackData.ElementAt(i) > 0x7F);
var eventLength = VariableLengthUtil.decode_to_int(lengthTemp);
i += 1;
var eventData = Enumerable.Range(i, eventLength).Select(trackData.ElementAt);
midiEvent = new SysexEvent(deltaTime, eventTypeValue, eventData);
i += eventLength;
}
}
return(midiEvent != null
? new Tuple <Option <MidiEvent>, int, byte>(new Some <MidiEvent>(midiEvent), i - startIndex, lastMidiChannel)
: new Tuple <Option <MidiEvent>, int, byte>(new None <MidiEvent>(), i - startIndex, lastMidiChannel));
}
public void Reset()
{
CurrentTempo = tempos[0];
Time = 0;
tempoIndex = 0;
}
