public void Apply(Region region)
{
// Just transposes, all we had time to implement
KeySignature harmonyKey = _harmony.MetaState.KeySignature;
KeySignature melodyKey = region.State.KeySignature;
int harmonyMajorTonic = harmonyKey.Scale == Scale.MAJOR
? (int)harmonyKey.Tonic : (int)harmonyKey.Tonic + 3;
int melodyMajorTonic = harmonyKey.Scale == Scale.MAJOR
? (int)melodyKey.Tonic : (int)melodyKey.Tonic + 3;
int interval = (harmonyMajorTonic - melodyMajorTonic) % 12;
region.State.KeySignature = harmonyKey;
foreach (TimedNote note in region)
{
note.Pitch += (byte)interval;
}
}
private static void RunOpenWallet(string fileName)
{
if (!File.Exists(fileName))
{
Console.WriteLine("Could not find wallet file: " + fileName);
return;
}
var jsonConfig = File.ReadAllText(fileName);
var walletFile = Newtonsoft.Json.JsonConvert.DeserializeObject <WalletConfig>(jsonConfig);
var signature = KeySignature.Sign(walletFile.PrivateKey, walletFile.PublicKey);
activeWallet = new Wallet()
{
Address = walletFile.PublicKey.Trim(),
PrivateKey = walletFile.PrivateKey.Trim(),
Signature = signature.Trim()
};
Console.WriteLine("Wallet opened successfully: " + activeWallet.Address);
}
/// <include file="documentation.xml" path="/UI/ListBase/CreateSignatureItem/*"/>
protected virtual KeySignatureItem CreateSignatureItem(KeySignature sig)
{
if(sig == null) throw new ArgumentNullException();
string name = string.IsNullOrEmpty(sig.SignerName) ? "(User ID not found)" : sig.SignerName;
if(sig.Revocation && sig.SelfSignature) name += " (self revocation)";
else if(sig.SelfSignature) name += " (self signature)";
else if(sig.Revocation) name += " (revocation)";
KeySignatureItem item = new KeySignatureItem(sig, name);
item.SubItems.Add(sig.ShortKeyId);
item.SubItems.Add((sig.Exportable ? "Exportable " : "Local ") + PGPUI.GetSignatureDescription(sig.Type));
item.SubItems.Add(sig.Expired ? "Expired" : sig.IsValid ? "Valid" : sig.IsInvalid ? "Invalid" :
sig.ErrorOccurred ? "Error" : "Unverified");
item.SubItems.Add(sig.CreationTime.ToShortDateString());
return item;
}
public override void readSong()
{
//HEADERS
//VERSION
version = readVersion();
versionTuple = readVersionTuple();
//INFORMATION ABOUT THE PIECE
readInfo();
_tripletFeel = GPBase.readBool()[0] ? TripletFeel.eigth : TripletFeel.none;
//readLyrics();
tempo = GPBase.readInt()[0];
key = (KeySignature)(GPBase.readInt()[0] * 10); //key + 0
//GPBase.readSignedByte(); //octave
readMidiChannels();
measureCount = GPBase.readInt()[0];
trackCount = GPBase.readInt()[0];
readMeasureHeaders(measureCount);
readTracks(trackCount, channels);
readMeasures();
}
void AddKeySignature(KeySignature keySignature)
{
EnsureVoice();
if (parsingInlineinformationField)
{
voice.items.Add(new Key(keySignature));
}
else
{
foreach (var voice in tune.voices)
{
if (voice.items.Count == 0)
{
voice.initialKey = keySignature;
}
else
{
voice.items.Add(new Key(keySignature));
}
}
}
}
public static bool IsFlat(this KeySignature keySignature)
{
return(keySignature >= KeySignature.Flats0);
}
// Convert a midi file to a song
public Song(String fileName, List <int[]> repeats)
{
chords.Clear();
BinaryReader br;
try
{
br = new BinaryReader(new FileStream(fileName, FileMode.Open));
}
catch (IOException e)
{
throw e;
} catch (ArgumentException e)
{
throw e;
}
// Read header
byte[] header = br.ReadBytes(14);
String mthd = Encoding.ASCII.GetString(header, 0, 4);
int headerLength = BitConverter.ToInt32(header.Skip(4).Take(4).Reverse().ToArray(), 0);
short format = BitConverter.ToInt16(header.Skip(8).Take(2).Reverse().ToArray(), 0);
short n = BitConverter.ToInt16(header.Skip(10).Take(2).Reverse().ToArray(), 0);
short division = BitConverter.ToInt16(header.Skip(12).Take(2).Reverse().ToArray(), 0);
Debug.WriteLine(mthd);
Debug.WriteLine(headerLength);
Debug.WriteLine(format);
Debug.WriteLine(n);
Debug.WriteLine(division);
if (mthd != "MThd" || headerLength != 6)
{
throw new FileFormatException();
}
// Only read first chunk
byte[] chunkHeader = br.ReadBytes(8);
String mtrk = Encoding.ASCII.GetString(chunkHeader, 0, 4);
int chunkLength = BitConverter.ToInt32(chunkHeader.Skip(4).Take(4).Reverse().ToArray(), 0);
Debug.WriteLine(mtrk);
Debug.WriteLine(chunkLength);
if (mtrk != "MTrk")
{
throw new FileFormatException();
}
byte[] chunk = br.ReadBytes(chunkLength);
int offset = 0;
bool noteOn = false;
bool endOfTrack = false;
int tempo = 0; // microseconds per quarter note
int timeSig = 0; // quarter notes per bar
KeySignature keySig = new KeySignature(0, true); // Initally C Major
byte[] noteValues = new byte[128];
byte[] oldValues = new byte[128];
int reftime = 0; // Time when current time signature first started
int ctime = 0; // Current time of track
int ltime = 0; // Time of last change
int refbar = 1;
int cbar = 1;
int returnBar = 1;
int endBar = -1;
if (repeats.Count > 0)
{
int[] repeat = repeats[0];
repeats.RemoveAt(0);
returnBar = repeat[0];
endBar = repeat[1];
}
bool notesChanged = false;
while (offset < chunkLength && !endOfTrack)
{
int delta = GetVarLength(chunk, ref offset);
if (delta > 0 && notesChanged)
{
// Create a chord out of currently played notes
int dtime = ctime - ltime;
byte dur = (byte)Math.Round(4 * (double)dtime / division);
Debug.WriteLine("ctime: {0} ltime: {1}", ctime, ltime);
if (dur > 0)
{
short bar = (short)(((ltime - reftime) / (division * timeSig)) + refbar);
byte[] notes = oldValues.Select((s, i) => new { i, s }).Where(t => t.s > 0).Select(t => (byte)t.i).ToArray();
Debug.WriteLine(String.Format("Dur: {0} Bar: {1} Notes: {2}", dur, bar, BitConverter.ToString(notes)));
if (notes.Length > 0)
{
chords.Add(new Chord(notes, dur, bar));
}
}
Array.Copy(noteValues, oldValues, 128);
notesChanged = false;
ltime = ctime;
}
ctime += delta;
if (division != 0 && timeSig != 0)
{
cbar = (int)((ctime - reftime) / (division * timeSig)) + refbar;
Debug.WriteLine(String.Format("Current time: {0} Current bar: {1}", ctime, cbar));
if (endBar != -1 && cbar > endBar)
{
cbar = returnBar;
if (repeats.Count > 0)
{
int[] repeat = repeats[0];
repeats.RemoveAt(0);
returnBar = repeat[0];
endBar = repeat[1];
}
else
{
endBar = -1;
}
}
}
// Debug.WriteLine(String.Format("Time delta: {0}", delta));
byte message = chunk[offset];
offset++;
if (message == 0xFF)
{
// Meta event
byte metaType = chunk[offset++];
int vlen = GetVarLength(chunk, ref offset);
byte[] vData = chunk.Skip(offset).Take(vlen).ToArray();
offset += vlen;
switch (metaType)
{
case 0x00:
// Sequence number
short seqNum = BitConverter.ToInt16(vData.Reverse().ToArray(), 0);
Debug.WriteLine(String.Format("Sequence number: {0}", seqNum));
ltime = ctime;
break;
case 0x01:
// Text event
Debug.WriteLine(String.Format("Text: {0}", Encoding.ASCII.GetString(vData)));
break;
case 0x02:
// Copyright notice
Debug.WriteLine(String.Format("Copyright: {0}", Encoding.ASCII.GetString(vData)));
break;
case 0x03:
// Sequence or track name
Debug.WriteLine(String.Format("Sequence Name: {0}", Encoding.ASCII.GetString(vData)));
break;
case 0x04:
// Instrument name
Debug.WriteLine(String.Format("Instrument Name: {0}", Encoding.ASCII.GetString(vData)));
break;
case 0x05:
// Lyric text
Debug.WriteLine(String.Format("Lyric: {0}", Encoding.ASCII.GetString(vData)));
break;
case 0x06:
// Marker text
Debug.WriteLine(String.Format("Marker: {0}", Encoding.ASCII.GetString(vData)));
break;
case 0x07:
// Cue point
Debug.WriteLine(String.Format("Cue Point: {0}", Encoding.ASCII.GetString(vData)));
break;
case 0x20:
// MIDI channel prefix assignment
byte channel = vData[0];
Debug.WriteLine(String.Format("MIDI Channel Prefix: {0}", channel));
break;
case 0x2F:
// End of track
endOfTrack = true;
Debug.WriteLine("End of track");
break;
case 0x51:
// Tempo setting
tempo = BitConverter.ToInt32(vData.Reverse().Concat(new byte[] { 0 }).ToArray(), 0);
Debug.WriteLine(String.Format("Tempo: {0}", tempo));
break;
case 0x54:
// SMPTE offset
byte hr = vData[0];
byte mn = vData[1];
byte se = vData[2];
byte fr = vData[3];
byte ff = vData[4];
Debug.WriteLine(String.Format("SMPTE offset: hr:{0} mn:{1} se:{2} fr:{3} ff:{4}", hr, mn, se, fr, ff));
break;
case 0x58:
// Time signature
byte nn = vData[0];
byte dd = vData[1];
byte cc = vData[2];
byte bb = vData[3];
Debug.WriteLine(String.Format("Time signature: {0}/{1}", nn, Math.Pow(2, dd)));
Debug.WriteLine(String.Format("MIDI clocks per metronome tick: {0}", cc));
Debug.WriteLine(String.Format("32nd notes per MIDI quarter note: {0}", bb));
timeSig = (int)(nn * Math.Pow(2, 2 - dd));
reftime = ctime;
if (cbar == 2)
{
cbar--; // Anacrusis
}
refbar = cbar;
break;
case 0x59:
sbyte sf = (sbyte)vData[0];
bool major = (vData[1] == 0);
// Key signature
keySig = new KeySignature(sf, major);
Debug.WriteLine(String.Format("Key signature: {0}", keySig.GetString));
break;
case 0x7F:
// Sequencer specific event
Debug.WriteLine(String.Format("Sequence specifier: {0}", BitConverter.ToString(vData)));
break;
default:
// Unknown event type
Debug.WriteLine("Unknown event type: {0} Len: {1} Data: {2}", metaType, vlen, BitConverter.ToString(vData));
break;
}
}
else if (message == 0xF0 || message == 0xF7)
{
// Sysex event
int vlen = GetVarLength(chunk, ref offset);
byte[] vData = chunk.Skip(offset).Take(vlen).ToArray();
offset += vlen;
Debug.WriteLine("Sysex event: Len: {0} Data: {1}", vlen, BitConverter.ToString(vData));
}
else
{
byte status = (byte)(message & 0xF0);
byte channel = (byte)(message & 0x0F);
byte key, val;
switch (status)
{
case 0x80:
// Note off event
noteOn = false;
key = (byte)(chunk[offset] & 0x7F);
offset++;
val = (byte)(chunk[offset] & 0x7F);
offset++;
Debug.WriteLine("Note off: Key: {0} Vol: {1}", key, val);
if (channel == 0)
{
noteValues[key] = 0;
}
notesChanged = true;
break;
case 0x90:
// Note on event
noteOn = true;
key = (byte)(chunk[offset] & 0x7F);
offset++;
val = (byte)(chunk[offset] & 0x7F);
offset++;
Debug.WriteLine("Note on: Key: {0} Vl: {1}", key, val);
if (channel == 0)
{
noteValues[key] = val;
}
notesChanged = true;
break;
case 0xA0:
noteOn = false;
// Polyphonic key pressure
key = (byte)(chunk[offset] & 0x7F);
offset++;
val = (byte)(chunk[offset] & 0x7F);
offset++;
Debug.WriteLine("Polyphonic key pressure: Key: {0} Pressure value: {1}", key, val);
break;
case 0xB0:
noteOn = false;
// Control change
byte controller = (byte)(chunk[offset] & 0x7F);
offset++;
val = (byte)(chunk[offset] & 0x7F);
offset++;
Debug.WriteLine("Control change: Controller number: {0} Vel: {1}", controller, val);
break;
case 0xC0:
noteOn = false;
// Program change
byte program = (byte)(chunk[offset] & 0x7F);
offset++;
Debug.WriteLine("Program change: {0}", program);
break;
case 0xD0:
noteOn = false;
// Channel pressure
val = (byte)(chunk[offset] & 0x7F);
offset++;
Debug.WriteLine("Channel pressure: {0}", val);
break;
case 0xE0:
noteOn = false;
// Pitch Wheel Change
short wheel = (short)((chunk[offset] & 0x7F) | ((chunk[offset + 1] & 0x7F) << 7));
offset += 2;
Debug.WriteLine("Pitch wheel change: {0}", wheel);
break;
default:
if (noteOn)
{
// Part of note on event
key = (byte)(message & 0x7F);
val = (byte)(chunk[offset] & 0x7F);
offset++;
Debug.WriteLine("Update note value: Key: {0} Vel: {1}", key, val);
noteValues[key] = val;
notesChanged = true;
}
else
{
// Unknown message type
Debug.WriteLine("Unknown message type: {0} Data: {1}", message, chunk[offset]);
offset++;
}
break;
}
}
}
br.Close();
}
/// <summary>Creates an object creation expression for an event.</summary>
/// <param name="ev">The event to create.</param>
/// <returns>The object creation expression for the event.</returns>
private static CodeObjectCreateExpression CreateMetaEvent(MidiEvent ev)
{
CodeObjectCreateExpression newEvent = null;
CodeExpression delta = new CodePrimitiveExpression(ev.DeltaTime);
// SEQUENCE NUMBER
if (ev is SequenceNumber)
{
SequenceNumber midiEvent = (SequenceNumber)ev;
newEvent = new CodeObjectCreateExpression(
typeof(SequenceNumber),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.Number)
});
}
// TEXT
else if (ev is Text)
{
Text midiEvent = (Text)ev;
newEvent = new CodeObjectCreateExpression(
typeof(Text),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.Text)
});
}
// Copyright
else if (ev is Copyright)
{
Copyright midiEvent = (Copyright)ev;
newEvent = new CodeObjectCreateExpression(
typeof(Copyright),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.Text)
});
}
// SEQUENCE TRACK NAME
else if (ev is SequenceTrackName)
{
SequenceTrackName midiEvent = (SequenceTrackName)ev;
newEvent = new CodeObjectCreateExpression(
typeof(SequenceTrackName),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.Text)
});
}
// INSTRUMENT
else if (ev is Instrument)
{
Instrument midiEvent = (Instrument)ev;
newEvent = new CodeObjectCreateExpression(
typeof(Instrument),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.Text)
});
}
// Lyric
else if (ev is Lyric)
{
Lyric midiEvent = (Lyric)ev;
newEvent = new CodeObjectCreateExpression(
typeof(Lyric),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.Text)
});
}
// Marker
else if (ev is Marker)
{
Marker midiEvent = (Marker)ev;
newEvent = new CodeObjectCreateExpression(
typeof(Marker),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.Text)
});
}
// CuePoint
else if (ev is CuePoint)
{
CuePoint midiEvent = (CuePoint)ev;
newEvent = new CodeObjectCreateExpression(
typeof(CuePoint),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.Text)
});
}
// ProgramName
else if (ev is ProgramName)
{
ProgramName midiEvent = (ProgramName)ev;
newEvent = new CodeObjectCreateExpression(
typeof(ProgramName),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.Text)
});
}
// ProgramName
else if (ev is DeviceName)
{
DeviceName midiEvent = (DeviceName)ev;
newEvent = new CodeObjectCreateExpression(
typeof(DeviceName),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.Text)
});
}
// ChannelPrefix
else if (ev is ChannelPrefix)
{
ChannelPrefix midiEvent = (ChannelPrefix)ev;
newEvent = new CodeObjectCreateExpression(
typeof(ChannelPrefix),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.Prefix)
});
}
// MidiPort
else if (ev is MidiPort)
{
MidiPort midiEvent = (MidiPort)ev;
newEvent = new CodeObjectCreateExpression(
typeof(MidiPort),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.Port)
});
}
// EndOfTrack
else if (ev is EndOfTrack)
{
EndOfTrack midiEvent = (EndOfTrack)ev;
newEvent = new CodeObjectCreateExpression(
typeof(EndOfTrack),
new CodeExpression[] {
delta
});
}
// Tempo
else if (ev is Tempo)
{
Tempo midiEvent = (Tempo)ev;
newEvent = new CodeObjectCreateExpression(
typeof(Tempo),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.Value)
});
}
// SMPTEOffset
else if (ev is SMPTEOffset)
{
SMPTEOffset midiEvent = (SMPTEOffset)ev;
newEvent = new CodeObjectCreateExpression(
typeof(SMPTEOffset),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.Hours),
new CodePrimitiveExpression(midiEvent.Minutes),
new CodePrimitiveExpression(midiEvent.Seconds),
new CodePrimitiveExpression(midiEvent.Frames),
new CodePrimitiveExpression(midiEvent.FractionalFrames)
});
}
// TimeSignature
else if (ev is TimeSignature)
{
TimeSignature midiEvent = (TimeSignature)ev;
newEvent = new CodeObjectCreateExpression(
typeof(TimeSignature),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.Numerator),
new CodePrimitiveExpression(midiEvent.Denominator),
new CodePrimitiveExpression(midiEvent.MidiClocksPerClick),
new CodePrimitiveExpression(midiEvent.NumberOfNotated32nds)
});
}
// KeySignature
else if (ev is KeySignature)
{
KeySignature midiEvent = (KeySignature)ev;
newEvent = new CodeObjectCreateExpression(
typeof(KeySignature),
new CodeExpression[] {
delta,
new CodeCastExpression(typeof(Key), new CodePrimitiveExpression((byte)midiEvent.Key)),
new CodeCastExpression(typeof(Tonality), new CodePrimitiveExpression((byte)midiEvent.Tonality))
});
}
// Proprietary
else if (ev is Proprietary)
{
Proprietary midiEvent = (Proprietary)ev;
newEvent = new CodeObjectCreateExpression(
typeof(Proprietary),
new CodeExpression[] {
delta,
CreateDataArray(midiEvent.Data)
});
}
// UnknownMetaMidiEvent
else if (ev is UnknownMetaMidiEvent)
{
UnknownMetaMidiEvent midiEvent = (UnknownMetaMidiEvent)ev;
newEvent = new CodeObjectCreateExpression(
typeof(UnknownMetaMidiEvent),
new CodeExpression[] {
delta,
new CodePrimitiveExpression(midiEvent.MetaEventID),
CreateDataArray(midiEvent.Data)
});
}
// Return the event
return(newEvent);
}
// Constructor
public CalculateAndStoreFromInputAndAsyncTerms(CalculateAndStoreFromInputAndAsyncTermsObservableData calculateAndStoreFromInputAndAsyncTermsObservableData, IWebGet webGet, CalculateAndStoreFromInputAndAsyncTermsOptions calculateAndStoreFromInputAndAsyncTermsOptions) : base(calculateAndStoreFromInputAndAsyncTermsOptions)
{
Log.Trace("Constructor starting");
_calculateAndStoreFromInputAndAsyncTermsObservableData = calculateAndStoreFromInputAndAsyncTermsObservableData;
_webGet = webGet;
_calculateAndStoreFromInputAndAsyncTermsOptions = calculateAndStoreFromInputAndAsyncTermsOptions;
// Create a place to store the TransientBuffers that buffer messages while waiting For all elements that make up the ElementSets Of Term1 to finish fetching
_transientBuffersForElementSetsOfTerm1 = new ConcurrentDictionary <string, Dataflow <IInternalMessage <string>, IInternalMessage <string> > >();
// foreach IInputMessage<TKeyTerm1,TValueTerm1>, create an internal message that adds the hashset for the terms1 and the bool used by the routing predicate
Log.Trace("Creating _bAccepter");
_bAccepter = new TransformBlock <IInputMessage <string, double>, IInternalMessage <string> >(_input => { Log.Trace("Accepter received IInputMessage");
// ToDo also check on the async tasks check when an upstream completion occurs
// ToDo add exception handling to ensure the tasks, as well as the async method's resources, are released if any blocks in the dataflow fault
// create a HashSet from the set of keys found in terms1
KeySignature <string> sig = new KeySignature <string>(_input.Value.terms1.Keys);
// Is the sig.largest in the ElementSetsOfTerm1Ready dictionary? set the output bool accordingly
bool isReadyToCalculate = _calculateAndStoreFromInputAndAsyncTermsObservableData.ElementSetsOfTerm1Ready.ContainsKey(sig.Longest());
// Pass the message along to the next block, which will be either the _bSolveStore, or the _bDynamicBuffers
return(new InternalMessage <string>((_input.Value.k1, _input.Value.k2, _input.Value.terms1, sig, isReadyToCalculate))); }).ToDataflow();
// this block accepts messages where isReadyToCalculate is false, and buffers them
Log.Trace("Creating _bDynamicBuffers");
_bDynamicBuffers = new DynamicBuffers(this);
// The terminator block performs both the Solve and the Store operations
Log.Trace("Creating _bSolveStore");
_bSolveStore = new ActionBlock <IInternalMessage <string> >(_input => { Log.Trace($"_bSolveStore received InternalMessage having signature {_input.Value.sig.Longest()}");
// solve the equation for the input and all terms
var r1 = 0.0;
foreach (var kvp in _input.Value.terms1)
{
r1 += kvp.Value /
_calculateAndStoreFromInputAndAsyncTermsObservableData.FetchedIndividualElementsOfTerm1[kvp.Key];
}
// Store the results value
calculateAndStoreFromInputAndAsyncTermsObservableData.RecordR(_input.Value.k1,
_input.Value.k2,
Convert.ToDecimal(r1)); }).ToDataflow(calculateAndStoreFromInputAndAsyncTermsOptions);
#region create asyncFetchCheckTimer and connect callback
// Create a timer that is used to check on the async fetch tasks, the async fetch tasks check-for-completion loop timer
// the timer has its interval from the options passed into this constructor, it will restart and the event handler will stop the timer and start the timer each time
// ToDo add the timer that checks on the health of the async fetch tasks check-for-completion loop every DefaultAsyncFetchTimeout interval, expecting it to provide a heartbeat,
// The Cleanup method will call this timers Dispose method
// the event handler's job is to call CheckAsyncTasks which will check for completed fetches and link the child Transient buffers to the _bSolveStore
Log.Trace("creating and starting the asyncFetchCheckTimer");
asyncFetchCheckTimer = new Timer(_calculateAndStoreFromInputAndAsyncTermsOptions.AsyncFetchTimeInterval.TotalMilliseconds);
asyncFetchCheckTimer.AutoReset = true;
// set the event handler (callback) for this timer to the function for async fetch tasks check-for-completion loop
asyncFetchCheckTimer.Elapsed += new ElapsedEventHandler(asyncFetchCheckTimer_Elapsed);
asyncFetchCheckTimer.Start();
#endregion create asyncFetchCheckTimer and connect callback
_bAccepter.Name = "_bAccepter";
_bSolveStore.Name = "_bSolveStore";
_bDynamicBuffers.Name = "_bDynamicBuffers";
// Link the data flow
Log.Trace("Linking dataflow between blocks");
// Link _bAccepter to _bSolveStore when the InternalMessage.Value has isReadyToCalculate = true
_bAccepter.LinkTo(_bSolveStore,
internalMessage => internalMessage.Value.isReadyToCalculate);
// Link _bAccepter to _bDynamicBuffers when the InternalMessage.Value has isReadyToCalculate = false
_bAccepter.LinkTo(_bDynamicBuffers,
internalMessage => !internalMessage.Value.isReadyToCalculate);
// data flow linkage of the dynamically created TransientBuffer children to the _bSolveStore is complex and handled elsewhere
// Link the completion tasks
Log.Trace("Linking completion between blocks");
_bDynamicBuffers.RegisterDependency(_bAccepter);
_bSolveStore.RegisterDependency(_bAccepter);
_bSolveStore.RegisterDependency(_bDynamicBuffers);
// Completion linkage of the dynamically created TransientBuffer children to the _bSolveStore is complex and handled elsewhere
Log.Trace("Registering Children");
this.RegisterChild(_bAccepter);
this.RegisterChild(_bSolveStore);
this.RegisterChild(_bDynamicBuffers);
// set the InputBlock for this dataflow graph to be the InputBlock of the _acceptor
this._headBlock = _bAccepter.InputBlock;
// ToDo: add an optional constructor parameter that supplies an initial list of elements that can start pre-fetching for each term
Log.Trace("Constructor Finished");
}
private MIDI ConvertToFormat1(MIDI src)
{
try
{
Track srcTrack = src.TrackList[0];
var newTracks = new List <Track>();
int cnt = 0; // event counter
var eventlist = new LinkedList <Event>();
uint deltaTime = 0;
// Create Conductor track
foreach (Event ev in srcTrack.EventList)
{
deltaTime += ev.DeltaTime;
if (ev is MetaEvent)
{
MetaEvent modEv;
if (ev is SetTempo)
{
var st = (SetTempo)ev;
modEv = new SetTempo(deltaTime, st.Value);
}
else if (ev is TimeSignature)
{
var ts = (TimeSignature)ev;
modEv = new TimeSignature(deltaTime, ts.Numerator, ts.DenominatorBitShift, ts.MIDIClockPerMetronomeTick, ts.NumberOfNotesPerClocks);
}
else if (ev is KeySignature)
{
var ks = (KeySignature)ev;
modEv = new KeySignature(deltaTime, ks.SignatureNumber, ks.MinorFlagNumber);
}
else if (ev is SequenceTrackName)
{
var stn = (SequenceTrackName)ev;
modEv = new SequenceTrackName(deltaTime, stn.Name);
}
else if (ev is EndOfTrack)
{
modEv = new EndOfTrack(deltaTime);
}
else
{
modEv = new MetaEvent(deltaTime);
}
eventlist.AddLast(modEv);
deltaTime = 0;
if (!(ev is EndOfTrack))
{
cnt++;
}
}
}
newTracks.Add(new Track(eventlist));
eventlist = new LinkedList <Event>();
deltaTime = 0;
// Create System Setup track
foreach (Event ev in srcTrack.EventList)
{
deltaTime += ev.DeltaTime;
if (ev is SysExEvent)
{
eventlist.AddLast(new SysExEvent(deltaTime));
deltaTime = 0;
cnt++;
}
else if (ev is EndOfTrack)
{
eventlist.AddLast(new EndOfTrack(deltaTime));
}
}
newTracks.Add(new Track(eventlist));
// Create Notes track
for (int ch = 0; cnt + 1 < srcTrack.EventList.Count; ch++)
{
eventlist = new LinkedList <Event>();
deltaTime = 0;
foreach (Event ev in srcTrack.EventList)
{
deltaTime += ev.DeltaTime;
if (ev is MIDIEvent)
{
var midiEv = (MIDIEvent)ev;
if (midiEv.Channel == ch)
{
MIDIEvent modEv;
if (midiEv is NoteOn)
{
var nton = (NoteOn)midiEv;
modEv = new NoteOn(deltaTime, nton.Channel, nton.Number, nton.Velocity);
}
else if (midiEv is NoteOff)
{
var ntoff = (NoteOff)midiEv;
modEv = new NoteOff(deltaTime, ntoff.Channel, ntoff.Number, ntoff.Velocity);
}
else if (midiEv is ProgramChange)
{
var pc = (ProgramChange)midiEv;
modEv = new ProgramChange(deltaTime, pc.Channel, pc.Number);
}
else if (midiEv is Volume)
{
var vol = (Volume)midiEv;
modEv = new Volume(deltaTime, vol.Channel, vol.Value);
}
else if (midiEv is Pan)
{
var pan = (Pan)midiEv;
modEv = new Pan(deltaTime, pan.Channel, pan.Value);
}
else if (midiEv is ControlChange)
{
var cc = (ControlChange)midiEv;
modEv = new ControlChange(deltaTime, cc.Channel, cc.Value);
}
else
{
modEv = new MIDIEvent(deltaTime, midiEv.Channel);
}
eventlist.AddLast(modEv);
deltaTime = 0;
cnt++;
}
}
else if (ev is EndOfTrack)
{
eventlist.AddLast(new EndOfTrack(deltaTime));
}
}
newTracks.Add(new Track(eventlist));
}
return(new MIDI(newTracks, 1, newTracks.Count, src.TimeDivision));
}
catch (Exception ex)
{
throw new Exception(Resources.ErrorMIDIFormat1, ex);
}
}
/// <summary>Parse a meta MIDI event from the data stream.</summary>
/// <param name="deltaTime">The previously parsed delta-time for this event.</param>
/// <param name="eventType">The previously parsed type of message we're expecting to find.</param>
/// <param name="data">The data stream from which to read the event information.</param>
/// <param name="pos">The position of the start of the event information.</param>
/// <returns>The parsed meta MIDI event.</returns>
private static MidiEvent ParseMetaEvent(long deltaTime, byte eventType, byte [] data, ref long pos)
{
try
{
MidiEvent tempEvent = null;
// Create the correct meta event based on its meta event id/type
switch (eventType)
{
// Sequence number
case 0x00:
pos++; // skip past the 0x02
int number = ((data[pos] << 8) | data[pos + 1]);
tempEvent = new SequenceNumber(deltaTime, number);
pos += 2; // skip read values
break;
// Text events (copyright, lyrics, etc)
case 0x01: tempEvent = new Text(deltaTime, ReadASCIIText(data, ref pos)); break;
case 0x02: tempEvent = new Copyright(deltaTime, ReadASCIIText(data, ref pos)); break;
case 0x03: tempEvent = new SequenceTrackName(deltaTime, ReadASCIIText(data, ref pos)); break;
case 0x04: tempEvent = new Instrument(deltaTime, ReadASCIIText(data, ref pos)); break;
case 0x05: tempEvent = new Lyric(deltaTime, ReadASCIIText(data, ref pos)); break;
case 0x06: tempEvent = new Marker(deltaTime, ReadASCIIText(data, ref pos)); break;
case 0x07: tempEvent = new CuePoint(deltaTime, ReadASCIIText(data, ref pos)); break;
case 0x08: tempEvent = new ProgramName(deltaTime, ReadASCIIText(data, ref pos)); break;
case 0x09: tempEvent = new DeviceName(deltaTime, ReadASCIIText(data, ref pos)); break;
// Channel prefix
case 0x20:
pos++; // skip 0x1
tempEvent = new ChannelPrefix(deltaTime, data[pos]);
pos++; // skip read value
break;
// Port number
case 0x21:
pos++; // skip 0x1
tempEvent = new MidiPort(deltaTime, data[pos]);
pos++; // skip read value
break;
// End of track
case 0x2F:
pos++; // skip 0x0
tempEvent = new EndOfTrack(deltaTime);
break;
// Tempo
case 0x51:
pos++; // skip 0x3
int tempo = ((data[pos] << 16) | data[pos + 1] << 8 | data[pos + 2]);
tempEvent = new Tempo(deltaTime, tempo);
pos += 3;
break;
// SMPTE offset
case 0x54:
pos++; // skip 0x5
tempEvent = new SMPTEOffset(deltaTime,
data[pos], data[pos + 1], data[pos + 2], data[pos + 3], data[pos + 4]);
pos += 5;
break;
// Time signature
case 0x58:
pos++; // skip past 0x4
tempEvent = new TimeSignature(deltaTime,
data[pos], data[pos + 1], data[pos + 2], data[pos + 3]);
pos += 4;
break;
// Key signature
case 0x59:
pos++; // skip past 0x2
tempEvent = new KeySignature(deltaTime, (Key)data[pos], (Tonality)data[pos + 1]);
pos += 2;
break;
// Proprietary
case 0x7F:
// Read in the variable length and that much data, then store it
long length = ReadVariableLength(data, ref pos);
byte [] propData = new byte[length];
Array.Copy(data, (int)pos, propData, 0, (int)length);
tempEvent = new Proprietary(deltaTime, propData);
pos += length;
break;
// An unknown meta event!
default:
// Read in the variable length and that much data, then store it
length = ReadVariableLength(data, ref pos);
byte [] unknownData = new byte[length];
Array.Copy(data, (int)pos, unknownData, 0, (int)length);
tempEvent = new UnknownMetaMidiEvent(deltaTime, eventType, unknownData);
pos += length;
break;
}
return(tempEvent);
}
// Something bad happened; wrap it in a parser exception
catch (Exception exc) { throw new MidiParserException("Unable to parse meta MIDI event.", exc, pos); }
}
/// <summary>
/// In MIDI Format 1, this would be the first track (index = 0).
/// Otherwise Format 0: index = 0 and with
/// Format 2, each track will essentially be like a Format 0 track.
///
/// This method collects information from the 'tempo map' track such as
///
/// - Tempo Information
/// - SMPTE Offset
/// - Time Signature
/// - Key Signatuer
/// - Sequencer Specific Data
/// - System Exclusive Data (in tempo map)
/// </summary>
int GetTempoMap(int nTrackIndex, int nTrackOffset, int delta)
{
int DELTA_Returned = delta;
var msg16 = FileHandle.Get16Bit(nTrackIndex, nTrackOffset);
byte msg8 = (byte)(msg16 & 0xFF);
CurrentStatus = msg16; // This is just an attempt at aligning running status.
// var hexMsg = $"{msg16:X2}";
if (msg16 >= 0xFF00 && msg16 <= 0xFF0C)
{
DELTA_Returned = FileHandle.Tracks[nTrackIndex].DeltaSeek(nTrackOffset);
return(++DELTA_Returned);
}
switch (msg16)
{
// text
case Stat16.SequenceNumber: // 0xFF00
case Stat16.ChannelPrefix: // 0xFF20
case Stat16.PortMessage: /* 0xFF21 */ DELTA_Returned = FileHandle.Tracks[nTrackIndex].DeltaSeek(nTrackOffset); break;
case Stat16.EndOfTrack: /* 0xFF2F */ DELTA_Returned = FileHandle.Tracks[nTrackIndex].Data.Length - 1; break;
case Stat16.SetTempo: // 0xFF51
var muspqn = FileHandle[ReaderIndex].ReadU24(nTrackOffset + 3);
TempoMap.Push(muspqn, Division, CurrentTrackPulse);
DELTA_Returned = FileHandle.Tracks[nTrackIndex].DeltaSeek(nTrackOffset);
break;
case Stat16.SMPTEOffset: // 0xFF54
SMPTE.SetSMPTE(
FileHandle.Tracks[nTrackIndex].Data[nTrackOffset + 3],
FileHandle.Tracks[nTrackIndex].Data[nTrackOffset + 4],
FileHandle.Tracks[nTrackIndex].Data[nTrackOffset + 5],
FileHandle.Tracks[nTrackIndex].Data[nTrackOffset + 6],
FileHandle.Tracks[nTrackIndex].Data[nTrackOffset + 7]
);
DELTA_Returned = FileHandle.Tracks[nTrackIndex].DeltaSeek(nTrackOffset);
break;
case Stat16.TimeSignature: // 0xFF58
TimeSignature.SetSignature(
(int)this[nTrackIndex, nTrackOffset + 3],
(int)Math.Pow(-this[nTrackIndex, nTrackOffset + 4], 2),
(int)this[nTrackIndex, nTrackOffset + 5],
(int)this[nTrackIndex, nTrackOffset + 6]
);
DELTA_Returned = FileHandle.Tracks[nTrackIndex].DeltaSeek(nTrackOffset);
break;
case Stat16.KeySignature: // 0xFF59
KeySignature.SetSignature(
this[nTrackIndex, nTrackOffset + 3],
this[nTrackIndex, nTrackOffset + 4]);
DELTA_Returned = FileHandle.Tracks[nTrackIndex].DeltaSeek(nTrackOffset);
break;
case Stat16.SequencerSpecific_70: // 0xFF70
case Stat16.SequencerSpecific_71: // 0xFF71
case Stat16.SequencerSpecific_72: // 0xFF72
case Stat16.SequencerSpecific_73: // 0xFF73
case Stat16.SequencerSpecific_74: // 0xFF74
case Stat16.SequencerSpecific_75: // 0xFF75
case Stat16.SequencerSpecific_76: // 0xFF76
case Stat16.SequencerSpecific_77: // 0xFF77
case Stat16.SequencerSpecific_78: // 0xFF78
case Stat16.SequencerSpecific_79: // 0xFF79
case Stat16.SequencerSpecific_7A: // 0xFF7A
case Stat16.SequencerSpecific_7B: // 0xFF7B
case Stat16.SequencerSpecific_7C: // 0xFF7C
case Stat16.SequencerSpecific_7D: // 0xFF7D
case Stat16.SequencerSpecific_7E: // 0xFF7E
case Stat16.SequencerSpecific: // 0xFF7F
DELTA_Returned = FileHandle.Tracks[nTrackIndex].DeltaSeek(nTrackOffset);
break;
case Stat16.SystemExclusive:
var pLastIndex = FileHandle[nTrackIndex].GetEndOfSystemExclusive(nTrackOffset);
DELTA_Returned = pLastIndex;
break;
default:
{
if (FileHandle.Tracks[nTrackIndex].Data[nTrackOffset] < 0x80)
{
CurrentStatus = CurrentRunningStatus16;
// Running Status
// int ExpandedRSE = CurrentTrackRunningStatus;// << 8;
int ExpandedRSE = CurrentRunningStatus8;// << 8;
int delta1 = -1;
if ((delta1 = Increment(nTrackOffset)) == -1)
{
int test = GetOffset(nTrackIndex, nTrackOffset);
Debug.Assert(false, string.Format("warning… {0:X2}, {1:X}|{1:N0}", ExpandedRSE, test));
}
else
{
DELTA_Returned = delta1;
}
}
else if (StatusQuery.IsMidiMessage(msg8))
{
CurrentRunningStatus8 = msg8;
CurrentRunningStatus16 = msg16;
DELTA_Returned = Increment(nTrackOffset + 1);
return(++DELTA_Returned);
}
else
{
throw new FormatException("Bad format!\nThere is probably a problem with the Input File unless we made an error reading it!)");
}
}
break;
}
return(++DELTA_Returned);
}
private TrackEvent ReadTrackEvent()
{
var deltaTime = ReadVariableLengthEncoding();
// "Running Status": The last status byte is implied
var statusByte = _lastStatusByte;
var firstByte = _source.ReadByte();
// Check for new status byte
if ((firstByte & 0x80) == 1)
{
statusByte = firstByte;
firstByte = _source.ReadByte();
}
var statusUpper = statusByte >> 4;
// Save running status
if (statusUpper > 0x7 && statusUpper < 0xF)
{
_lastStatusByte = statusByte;
}
// Parse the event
var statusLower = (byte)(statusByte & 0xF);
MidiEvent ev = null;
switch (statusUpper)
{
case 0x8:
ev = new NoteOff(statusLower, firstByte, _source.ReadByte());
break;
case 0x9:
ev = new NoteOn(statusLower, firstByte, _source.ReadByte());
break;
case 0xA:
ev = new PolyphonicKeyPressure(statusLower, firstByte, _source.ReadByte());
break;
case 0xB:
if (firstByte < 120)
{
ev = new ControlChange(statusLower, firstByte, _source.ReadByte());
}
else
{
ev = new ChannelMode(statusLower, firstByte, _source.ReadByte());
}
break;
case 0xC:
ev = new ProgramChange(statusLower, firstByte);
break;
case 0xD:
ev = new ChannelPressure(statusLower, firstByte);
break;
case 0xE:
ev = new PitchBend(statusLower, firstByte, _source.ReadByte());
break;
case 0xF:
switch (statusLower)
{
case 0x0:
case 0x7:
ev = new SysEx(statusLower == 0, _source.ReadBytes(ReadVariableLengthEncoding(firstByte)));
break;
case 0xF:
var len = ReadVariableLengthEncoding();
var data = _source.ReadBytes(len);
switch (firstByte)
{
case 0x01:
case 0x02:
case 0x03:
case 0x04:
case 0x05:
case 0x06:
case 0x07:
case 0x08:
case 0x09:
case 0x0A:
case 0x0B:
case 0x0C:
case 0x0D:
case 0x0E:
case 0x0F:
ev = new TextEvent(Encoding.UTF8.GetString(data)); // TODO: Let user choose encoding
break;
case 0x20:
ev = new ChannelPrefix(data[0]);
break;
case 0x2F:
ev = new EndOfTrack();
break;
case 0x51:
ev = new SetTempo(MidiBytesConverter.ReadBigEndian24Bit(data));
break;
case 0x54:
ev = new SmpteOffset((byte)((data[0] >> 5) & 0x3), (byte)(data[0] & 0x1F), data[1], data[2], data[3], data[4]);
break;
case 0x58:
ev = new TimeSignature(data[0], data[1], data[2], data[3]);
break;
case 0x59:
ev = new KeySignature((sbyte)data[0], data[1] == 1);
break;
case 0x7F:
ev = new SequencerSpecificMetaEvent(data);
break;
default:
// TODO: Unrecognized metadata kind, non-fatal error
break;
}
break;
default:
// At this point, if the event was not recognized: FATAL ERROR!
throw new NotImplementedException();
}
break;
default:
// At this point, if the event was not recognized: FATAL ERROR!
throw new NotImplementedException();
}
return(new TrackEvent(deltaTime, ev));
}
/// <summary>Initializes a new <see cref="KeySignatureItem"/> with the <see cref="KeySignature"/> that it represents,
/// and the text of the item.
/// </summary>
public KeySignatureItem(KeySignature sig, string text) : base(text)
{
if(sig == null) throw new ArgumentNullException();
this.sig = sig;
}
/// <summary>Initializes a new <see cref="KeySignatureItem"/> with the <see cref="KeySignature"/> that it represents.</summary>
public KeySignatureItem(KeySignature sig) : this(sig, null) { }
public MetaEventAffecterKeySignature(KeySignature aKeySignature)
: base(aKeySignature)
{
}
public Key(KeySignature signature, ScaleType scale)
{
Signature = signature;
Scale = scale;
}
public static bool IsSharp(this KeySignature keySignature)
{
return(keySignature > KeySignature.None && keySignature < KeySignature.Flats0);
}
public Key(KeySignature signature) : base(Item.Type.Key)
{
this.signature = signature;
}
/// MESSAGE PARSER see 'ParseTrackMeta'
public virtual int GetTrackTiming(int ntrack, int position, int delta)
{
int DELTA_Returned = delta;
byte CurrentByte = SmfFileHandle.Get8Bit(ntrack, position);
int CurrentIntMessage = SmfFileHandle.Get16BitInt32(ntrack, position);
switch (CurrentIntMessage)
{
case (int)MetaMsgU16FF.Text:
case (int)MetaMsgU16FF.Copyright:
case (int)MetaMsgU16FF.SequenceName:
case (int)MetaMsgU16FF.InstrumentName:
case (int)MetaMsgU16FF.Lyric:
case (int)MetaMsgU16FF.Marker:
case (int)MetaMsgU16FF.Cue:
case (int)MetaMsgU16FF.Port:
case (int)MetaMsgU16FF.SequenceNo:
case (int)MetaMsgU16FF.Chanel:
case (int)MetaMsgU16FF.EndOfTrack:
case (int)MetaMsgU16FF.SMPTE:
DELTA_Returned = GetMetaNextPos(position);
break;
case (int)MetaMsgU16FF.Tempo:
MidiTimeInfo.Tempo = 60000000 / Convert.ToInt32(SmfFileHandle[ntrack].Get24Bit(position + 3));
DELTA_Returned = GetMetaNextPos(position);
break;
case (int)MetaMsgU16FF.TimeSignature:
TimeSignature.SetSignature(
(int)this[ntrack, position + 3],
(int)Math.Pow(-this[ntrack, position + 4], 2),
(int)this[ntrack, position + 5],
(int)this[ntrack, position + 6]
);
DELTA_Returned = GetMetaNextPos(position);
break;
case (int)MetaMsgU16FF.KeySignature:
byte b = (this[ntrack, position + 3]);
KeySignature.SetSignature((KeySignatureType)b, this[ntrack, position + 4] == 0);
DELTA_Returned = GetMetaNextPos(position);
break;
case (int)MetaMsgU16FF.SystemSpecific:
case (int)MetaMsgU16FF.SystemExclusive:
DELTA_Returned = GetMetaNextPos(position);
break;
default:
{
if (CurrentByte < 0x80)
{
// Running Status
int ExpandedRSE = RunningStatus32 << 8;
int delta1 = -1;
if ((delta1 = GetNextRsePosition(position)) == -1)
{
int test = GetOffset(position);
Debug.Assert(false, string.Format("warning… {0:X2}, {1:X}|{1:N0}", ExpandedRSE, test));
}
else
{
DELTA_Returned = delta1;
}
}
else if (MidiMessageInfo.IsMidiMessage(CurrentIntMessage))
{
RunningStatus32 = (SmfFileHandle[ntrack, position]);
DELTA_Returned = GetNextPosition(position);
DELTA_Returned++;
return(DELTA_Returned);
}
else
{
throw new FormatException("Bad format!\nThere is probably a problem with the Input File unless we made an error reading it!)");
}
}
break;
}
DELTA_Returned++;
return(DELTA_Returned);
}
public KeySignatureMetaMessage(KeySignature keySignature,
long timeDelta)
{
KeySignature = keySignature;
TimeDelta = timeDelta;
}
