930 lines
23 KiB
C#
930 lines
23 KiB
C#
/*
|
|
|
|
Copyright (C) Arnaud Houdelette 2012-2014
|
|
Copyright (C) Emmanuel Langlois 2012-2014
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
using System;
|
|
using System.Runtime.InteropServices;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text.RegularExpressions;
|
|
|
|
namespace DMX2
|
|
{
|
|
public class MidiEventProvider : IEventProvider, IDisposable
|
|
{
|
|
/// <summary>
|
|
/// Etat interne des evenements midi paginés.
|
|
/// </summary>
|
|
readonly Dictionary<string, internalEventDesc> eventlist = new Dictionary<string, internalEventDesc>();
|
|
|
|
/// <summary>
|
|
/// Liste des peripheriques connus (presents ou non)
|
|
/// </summary>
|
|
readonly Dictionary<string, MidiControler> knowndevices = new Dictionary<string, MidiControler>();
|
|
|
|
/// <summary>
|
|
/// Liste des ports connectés avec feedback
|
|
/// </summary>
|
|
readonly List<AlsaSeqLib.Port> feedbacksources = new List<AlsaSeqLib.Port>();
|
|
|
|
//static readonly Dictionary<int,MidiDev> srcidToDev = new Dictionary<int, MidiDev>();
|
|
readonly List<byte> unpaginatedchannels = new List<byte>();
|
|
|
|
/// <summary>
|
|
/// Derniere valeur connue pour une evenement sur source donnée :
|
|
/// Soit recue, soit envoyée (feedback / changement de page)
|
|
/// </summary>
|
|
readonly Dictionary<int, byte> lastValueOfSrc = new Dictionary<int, byte>();
|
|
// EventData last;
|
|
internalEventDesc levent = null;
|
|
bool guirefreshflag = false;
|
|
uint page = 1;
|
|
uint maxpage = 8;
|
|
|
|
protected bool use14b = false;
|
|
protected int max14bValue = 100;
|
|
byte[] fbTmpData = new byte[512];
|
|
uint pageUpCC = 127;
|
|
uint pageDownCC = 126;
|
|
|
|
AlsaSeqLib.MidiPort midiport;
|
|
|
|
public uint CurrentPage
|
|
{
|
|
get
|
|
{
|
|
return page;
|
|
}
|
|
set
|
|
{
|
|
if (value < 1 || value > maxpage)
|
|
return;
|
|
page = value;
|
|
Refresh();
|
|
}
|
|
}
|
|
public uint PageUpCC
|
|
{
|
|
get
|
|
{
|
|
return pageUpCC;
|
|
}
|
|
set
|
|
{
|
|
pageUpCC = value;
|
|
}
|
|
}
|
|
public uint PageDownCC
|
|
{
|
|
get
|
|
{
|
|
return pageDownCC;
|
|
}
|
|
set
|
|
{
|
|
pageDownCC = value;
|
|
}
|
|
}
|
|
|
|
public uint Maxpage
|
|
{
|
|
get
|
|
{
|
|
return maxpage;
|
|
}
|
|
set
|
|
{
|
|
maxpage = value;
|
|
}
|
|
}
|
|
public List<byte> UnpaginatedChannels
|
|
{
|
|
get
|
|
{
|
|
return unpaginatedchannels;
|
|
}
|
|
}
|
|
|
|
public bool Use14bCC
|
|
{
|
|
get
|
|
{
|
|
return use14b;
|
|
}
|
|
set
|
|
{
|
|
use14b = value;
|
|
}
|
|
}
|
|
public int Max14bValue
|
|
{
|
|
get
|
|
{
|
|
return max14bValue;
|
|
}
|
|
set
|
|
{
|
|
max14bValue = value;
|
|
}
|
|
}
|
|
|
|
public bool GuiRefreshFlag
|
|
{
|
|
get
|
|
{
|
|
if (guirefreshflag)
|
|
{
|
|
guirefreshflag = false;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public void ConnectDevice(string name)
|
|
{
|
|
knowndevices.Add(name, new MidiControler(name));
|
|
AutoConnect();
|
|
}
|
|
|
|
public void RefreshFeedback(string name)
|
|
{
|
|
foreach (AlsaSeqLib.Port port in knowndevices[name].ConnectedPorts)
|
|
{
|
|
if (knowndevices[name].HasFeedback)
|
|
{
|
|
if (!feedbacksources.Contains(port))
|
|
feedbacksources.Add(port);
|
|
}
|
|
else
|
|
{
|
|
if (feedbacksources.Contains(port))
|
|
feedbacksources.Remove(port);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void DisconnectDevice(MidiEventProvider.MidiControler dev)
|
|
{
|
|
if (!knowndevices.ContainsKey(dev.Name))
|
|
return;
|
|
knowndevices.Remove(dev.Name);
|
|
|
|
foreach (AlsaSeqLib.Port connectedport in dev.ConnectedPorts)
|
|
{
|
|
midiport.Deconnecte(connectedport);
|
|
}
|
|
}
|
|
|
|
public bool IsKnownDevice(string name)
|
|
{
|
|
return knowndevices.ContainsKey(name);
|
|
}
|
|
|
|
public IEnumerable<MidiControler> KnownDevices
|
|
{
|
|
get
|
|
{
|
|
return knowndevices.Values;
|
|
}
|
|
}
|
|
|
|
public MidiEventProvider(EventManager manager)
|
|
{
|
|
#if DEBUG
|
|
MidiControler dev = new MidiControler("VMPK Input:VMPK Input");
|
|
dev.HasFeedback = true;
|
|
knowndevices.Add(dev.Name, dev);
|
|
dev = new MidiControler("VMPK Output:VMPK Output");
|
|
dev.HasFeedback = true;
|
|
knowndevices.Add(dev.Name, dev);
|
|
#endif
|
|
manager.RegisterProvider(this);
|
|
//AlsaSeqLib.Init ();
|
|
|
|
midiport = new AlsaSeqLib.MidiPort("event_prov_in_out");
|
|
//midiport.ConnectFrom(AlsaSeqLib.SND_SEQ_CLIENT_SYSTEM, AlsaSeqLib.SND_SEQ_PORT_SYSTEM_ANNOUNCE);
|
|
AlsaSeqLib.Port systemport = AlsaSeqLib.GetPortByIDs(AlsaSeqLib.SND_SEQ_CLIENT_SYSTEM, AlsaSeqLib.SND_SEQ_PORT_SYSTEM_ANNOUNCE);
|
|
midiport.ConnectFrom(systemport);
|
|
|
|
AutoConnect();
|
|
}
|
|
|
|
void AutoConnect()
|
|
{
|
|
foreach (var cli in AlsaSeqLib.EnumClients())
|
|
{
|
|
foreach (var p in cli.Ports)
|
|
{
|
|
PortDetected(cli, p);
|
|
}
|
|
}
|
|
}
|
|
|
|
void PortDetected(AlsaSeqLib.Client cli, AlsaSeqLib.Port p)
|
|
{
|
|
// Execute a chaque 'apparition' d'un port midi
|
|
|
|
// teste si connection auto au port et connecte si besoin
|
|
|
|
guirefreshflag = true;
|
|
|
|
string fullportname = cli.Name + ':' + p.Name;
|
|
if (knowndevices.ContainsKey(fullportname))
|
|
{
|
|
int srcid = p.ClientId << 8 + p.PortId;
|
|
if (knowndevices[fullportname].ConnectedPorts.Contains(p))
|
|
return;
|
|
|
|
midiport.ConnectFrom(p);
|
|
midiport.ConnectTo(p);
|
|
}
|
|
}
|
|
|
|
void PortConnect(AlsaSeqLib.snd_seq_connect_t cn, bool connect)
|
|
{
|
|
int clientId, portId;
|
|
if (cn.dest.client == AlsaSeqLib.ClientId)
|
|
{
|
|
clientId = cn.sender.client;
|
|
portId = cn.sender.port;
|
|
}
|
|
else
|
|
{
|
|
clientId = cn.dest.client;
|
|
portId = cn.dest.port;
|
|
}
|
|
|
|
AlsaSeqLib.Port p = AlsaSeqLib.GetPortByIDs(clientId, portId);
|
|
|
|
if (connect)
|
|
{
|
|
AlsaSeqLib.Client c = AlsaSeqLib.GetClientByID(clientId);
|
|
string fpname = c.Name + ":" + p.Name;
|
|
if (!knowndevices.ContainsKey(fpname))
|
|
return;
|
|
if (knowndevices[fpname].ConnectedPorts.Contains(p))
|
|
return;
|
|
knowndevices[fpname].ConnectedPorts.Add(p);
|
|
if (knowndevices[fpname].HasFeedback)
|
|
feedbacksources.Add(p);
|
|
guirefreshflag = true;
|
|
|
|
//srcidToDev[srcid] = knowndevices [fpname];
|
|
|
|
return;
|
|
}
|
|
|
|
foreach (var dev in knowndevices.Values)
|
|
{
|
|
if (dev.ConnectedPorts.Contains(p))
|
|
{
|
|
dev.ConnectedPorts.Remove(p);
|
|
guirefreshflag = true;
|
|
return;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
static int CombineHash(int hash1, int hash2)
|
|
{
|
|
unchecked
|
|
{
|
|
return hash1 * 33 + hash2;
|
|
}
|
|
}
|
|
|
|
protected bool HasFeedback(AlsaSeqLib.Port source)
|
|
{
|
|
return feedbacksources.Contains(source);
|
|
}
|
|
|
|
public void SendEvent(AlsaSeqLib.snd_seq_event_t ev)
|
|
{
|
|
midiport.SendEvent(ev);
|
|
}
|
|
|
|
public void Refresh()
|
|
{
|
|
foreach (var ievent in eventlist.Values)
|
|
{
|
|
if (ievent.Page == page)
|
|
{
|
|
ievent.SendFeedback();
|
|
foreach (AlsaSeqLib.Port src in feedbacksources)
|
|
{
|
|
int lnvk = CombineHash(src.SrcId, ievent.MidiEvCode);
|
|
if (ievent.LastKnownValue != -1)
|
|
lastValueOfSrc[lnvk] = (byte)ievent.LastKnownValue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#region IEventProvider implementation
|
|
|
|
|
|
|
|
bool IEventProvider.Bind(string eventId)
|
|
{
|
|
// On indique a l'EventManager qu'on traite, si l'ID commence par 'MIDI-'
|
|
if (!eventId.StartsWith("MIDI-"))
|
|
return false;
|
|
|
|
if (!eventlist.ContainsKey(eventId))
|
|
{
|
|
Match res = regexEventID.Match(eventId);
|
|
if (!res.Success)
|
|
return false;
|
|
uint _page = uint.Parse(res.Groups["page"].Value);
|
|
int _evHC = res.Groups["id"].Value.GetHashCode();
|
|
midiFeedbackSender sender = null;
|
|
|
|
res = regexCtrlEventID.Match(eventId);
|
|
if (res.Success)
|
|
{
|
|
byte chan = byte.Parse(res.Groups["chan"].Value);
|
|
uint param = uint.Parse(res.Groups["param"].Value);
|
|
sender = new midiCCFbSender(this, chan, param);
|
|
}
|
|
else if ((res = regexPbEventID.Match(eventId)).Success)
|
|
{
|
|
byte chan = byte.Parse(res.Groups["chan"].Value);
|
|
sender = new midiPBFbSender(this, chan);
|
|
}
|
|
eventlist.Add(eventId, new internalEventDesc(eventId, _page, _evHC, sender));
|
|
}
|
|
|
|
eventlist[eventId].Bound = true;
|
|
return true;
|
|
}
|
|
|
|
void IEventProvider.Unbind(string eventId)
|
|
{
|
|
if (!eventlist.ContainsKey(eventId))
|
|
return;
|
|
eventlist[eventId].Bound = false;
|
|
return;
|
|
}
|
|
|
|
Gtk.Menu IEventProvider.GetProviderSubMenu(EventManager.EventMenuData state, Gtk.ButtonPressEventHandler handler)
|
|
{
|
|
Gtk.Menu retmenu = new Gtk.Menu();
|
|
|
|
if (levent != null)
|
|
{ // Creation du sous menu "Dernier"
|
|
/*Gtk.MenuItem lmenuitem = new Gtk.MenuItem ("Dernier");
|
|
retmenu.Add (lmenuitem);
|
|
Gtk.Menu lmenu = new Gtk.Menu ();
|
|
lmenuitem.Submenu = lmenu;*/
|
|
Gtk.MenuItem item = new Gtk.MenuItem(GetDescription(levent.InternalName));
|
|
item.Data[EventManager.EventIdKey] = levent.InternalName;
|
|
item.Data[EventManager.StateKey] = state;
|
|
item.ButtonPressEvent += handler;
|
|
retmenu.Add(item);
|
|
}
|
|
|
|
Gtk.MenuItem evmenuitem = new Gtk.MenuItem("Events"); // Creation du sous menu "Events"
|
|
retmenu.Add(evmenuitem);
|
|
Gtk.Menu evmenu = new Gtk.Menu();
|
|
evmenuitem.Submenu = evmenu;
|
|
|
|
List<string> sortedKeys = eventlist.Keys.ToList(); // On recupere des IDs
|
|
sortedKeys.Sort(); // et on les trie
|
|
|
|
foreach (string key in sortedKeys)
|
|
{
|
|
internalEventDesc evt = eventlist[key];
|
|
Gtk.MenuItem item = new Gtk.MenuItem(GetDescription(evt.InternalName));
|
|
item.Data[EventManager.EventIdKey] = evt.InternalName;
|
|
item.Data[EventManager.StateKey] = state;
|
|
item.ButtonPressEvent += handler;
|
|
evmenu.Add(item);
|
|
}
|
|
|
|
return retmenu;
|
|
|
|
}
|
|
|
|
void IEventProvider.ProcessEvents(EventManagerCallback callback)
|
|
{
|
|
AlsaSeqLib.snd_seq_event_t evS;
|
|
uint evpage;
|
|
|
|
// Tant qu'il y des evenements midi en attente
|
|
while (midiport.GetEvent(out evS))
|
|
{
|
|
Console.WriteLine(string.Format("event {0}", evS.type));
|
|
string id = null;
|
|
int value = 0;
|
|
byte channel = 255;
|
|
|
|
switch (evS.type)
|
|
{
|
|
case AlsaSeqLib.snd_seq_event_type_t.SND_SEQ_EVENT_PORT_SUBSCRIBED: // Connection d'un périph midi
|
|
case AlsaSeqLib.snd_seq_event_type_t.SND_SEQ_EVENT_PORT_UNSUBSCRIBED:
|
|
PortConnect(
|
|
evS.data_connect,
|
|
evS.type == AlsaSeqLib.snd_seq_event_type_t.SND_SEQ_EVENT_PORT_SUBSCRIBED
|
|
);
|
|
continue;
|
|
case AlsaSeqLib.snd_seq_event_type_t.SND_SEQ_EVENT_CONTROLLER:
|
|
if (evS.data_ev_ctrl.param == pageUpCC && evS.data_ev_ctrl.value > 0)
|
|
{
|
|
CurrentPage++;
|
|
continue;
|
|
}
|
|
|
|
if (evS.data_ev_ctrl.param == pageDownCC && evS.data_ev_ctrl.value > 0)
|
|
{
|
|
CurrentPage--;
|
|
continue;
|
|
}
|
|
|
|
channel = evS.data_ev_ctrl.channel;
|
|
|
|
if (use14b && evS.data_ev_ctrl.param < 64)
|
|
{
|
|
long msbAddr;
|
|
if (evS.data_ev_ctrl.param < 32)
|
|
{
|
|
msbAddr = evS.data_ev_ctrl.channel * 32 + evS.data_ev_ctrl.param;
|
|
fbTmpData[msbAddr] = (byte)evS.data_ev_ctrl.value;
|
|
continue;
|
|
}
|
|
evS.data_ev_ctrl.param -= 32;
|
|
msbAddr = evS.data_ev_ctrl.channel * 32 + evS.data_ev_ctrl.param;
|
|
value = ((fbTmpData[msbAddr] << 7) ^ evS.data_ev_ctrl.value);
|
|
value = 255 * value / max14bValue;
|
|
if (value > 255) value = 255;
|
|
}
|
|
else
|
|
{
|
|
value = 255 * evS.data_ev_ctrl.value / 127; // Conversion {0,127} => {0,255}
|
|
}
|
|
id = string.Format("CTRL-C{0}P{1}", evS.data_ev_ctrl.channel, evS.data_ev_ctrl.param);
|
|
break;
|
|
case AlsaSeqLib.snd_seq_event_type_t.SND_SEQ_EVENT_NOTEON:
|
|
id = string.Format("NOTE-C{0}N{1}", evS.data_ev_note.channel, evS.data_ev_note.note);
|
|
channel = evS.data_ev_note.channel;
|
|
value = 255;
|
|
break;
|
|
case AlsaSeqLib.snd_seq_event_type_t.SND_SEQ_EVENT_NOTEOFF:
|
|
id = string.Format("NOTE-C{0}N{1}", evS.data_ev_note.channel, evS.data_ev_note.note);
|
|
channel = evS.data_ev_note.channel;
|
|
value = 0;
|
|
break;
|
|
case AlsaSeqLib.snd_seq_event_type_t.SND_SEQ_EVENT_PITCHBEND:
|
|
id = string.Format("PB-C{0}", evS.data_ev_ctrl.channel);
|
|
channel = evS.data_ev_ctrl.channel;
|
|
value = ((evS.data_ev_ctrl.value + 7000) * 255 / 14000);
|
|
if (value < 0)
|
|
value = 0;
|
|
if (value > 255)
|
|
value = 255;
|
|
break;
|
|
case AlsaSeqLib.snd_seq_event_type_t.SND_SEQ_EVENT_PGMCHANGE:
|
|
//CurrentPage = (uint)evS.data_ev_ctrl.value;
|
|
continue;
|
|
case AlsaSeqLib.snd_seq_event_type_t.SND_SEQ_EVENT_PORT_START:
|
|
PortDetected(
|
|
AlsaSeqLib.GetClientByID(evS.data_addr.client),
|
|
AlsaSeqLib.GetPortByIDs(evS.data_addr.client,evS.data_addr.port)
|
|
);
|
|
continue;
|
|
/*case AlsaSeqLib.snd_seq_event_type_t.SND_SEQ_EVENT_CLOCK:
|
|
case AlsaSeqLib.snd_seq_event_type_t.SND_SEQ_EVENT_SENSING:
|
|
continue;*/
|
|
|
|
default:
|
|
id = null;
|
|
#if DEBUG
|
|
Console.WriteLine(string.Format("event {0}", evS.type));
|
|
Info.Publish(string.Format("event {0}", evS.type)); // On affiche les evenements inconnus
|
|
#endif
|
|
continue;
|
|
}
|
|
|
|
if (id != null)
|
|
{
|
|
// Hashcode de l'ev Midi, non pagine
|
|
int evHC = id.GetHashCode();
|
|
int srcid = evS.source.client << 8 + evS.source.port;
|
|
int lnvk = CombineHash(srcid, evHC);
|
|
|
|
if (channel == 255 || unpaginatedchannels.Contains(channel))
|
|
evpage = 0;
|
|
else
|
|
evpage = page;
|
|
|
|
// Construction de l'ID evenement
|
|
id = string.Format("MIDI-PAGE{0}-{1}", evpage, id);
|
|
|
|
// Creation de l'objet interne si innexistant
|
|
if (!eventlist.ContainsKey(id))
|
|
{
|
|
switch (evS.type)
|
|
{
|
|
// TODO : Pitchbend feedback
|
|
case AlsaSeqLib.snd_seq_event_type_t.SND_SEQ_EVENT_CONTROLLER:
|
|
eventlist.Add(id, new internalEventDesc(id, evpage, evHC,
|
|
new midiCCFbSender(this, channel, evS.data_ev_ctrl.param))
|
|
);
|
|
break;
|
|
case AlsaSeqLib.snd_seq_event_type_t.SND_SEQ_EVENT_PITCHBEND:
|
|
eventlist.Add(id, new internalEventDesc(id, evpage, evHC,
|
|
new midiPBFbSender(this, channel))
|
|
);
|
|
break;
|
|
default:
|
|
eventlist.Add(id, new internalEventDesc(id, evpage, evHC, null));
|
|
break;
|
|
}
|
|
}
|
|
levent = eventlist[id]; //Dernier Evenement recu conserve pour menu
|
|
|
|
if (!lastValueOfSrc.ContainsKey(lnvk))
|
|
{
|
|
lastValueOfSrc[lnvk] = (byte)value;
|
|
}
|
|
else if (lastValueOfSrc[lnvk] == (byte)value)
|
|
continue;
|
|
|
|
EventData evData = new EventData();
|
|
evData.id = id;
|
|
evData.value = (byte)value;
|
|
evData.prev_value = lastValueOfSrc[lnvk];
|
|
/*if (evData.Equals (last))
|
|
continue; */
|
|
//last = evData;
|
|
|
|
eventlist[id].CallEvent(callback, evData);
|
|
|
|
/*if (eventlist [id].Bound) {
|
|
callback (evData);
|
|
}*/
|
|
|
|
lastValueOfSrc[lnvk] = (byte)value;
|
|
eventlist[id].LastKnownValue = (byte)value;
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
string IEventProvider.MenuName
|
|
{
|
|
get
|
|
{
|
|
return "Midi";
|
|
}
|
|
}
|
|
|
|
static System.Text.RegularExpressions.Regex regexEventID = new System.Text.RegularExpressions.Regex(
|
|
@"MIDI-PAGE(?<page>\d+)-(?<id>.+)",
|
|
System.Text.RegularExpressions.RegexOptions.Compiled);
|
|
|
|
static System.Text.RegularExpressions.Regex regexCtrlEventID = new System.Text.RegularExpressions.Regex(
|
|
@"MIDI-PAGE(?<page>\d+)-CTRL-C(?<chan>\d+)P(?<param>\d+)",
|
|
System.Text.RegularExpressions.RegexOptions.Compiled);
|
|
static System.Text.RegularExpressions.Regex regexPbEventID = new System.Text.RegularExpressions.Regex(
|
|
@"MIDI-PAGE(?<page>\d+)-PB-C(?<chan>\d+)",
|
|
System.Text.RegularExpressions.RegexOptions.Compiled);
|
|
static System.Text.RegularExpressions.Regex regexNoteEventID = new System.Text.RegularExpressions.Regex(
|
|
@"MIDI-PAGE(?<page>\d+)-NOTE-C(?<chan>\d+)N(?<note>\d+)",
|
|
System.Text.RegularExpressions.RegexOptions.Compiled);
|
|
|
|
string GetDescription(string eventId)
|
|
{
|
|
if (!eventlist.ContainsKey(eventId))
|
|
return null;
|
|
|
|
var res = regexCtrlEventID.Match(eventId);
|
|
if (res.Success)
|
|
{
|
|
uint page = uint.Parse(res.Groups["page"].Value);
|
|
byte chan = byte.Parse(res.Groups["chan"].Value);
|
|
uint param = uint.Parse(res.Groups["param"].Value);
|
|
return string.Format("Page {2} => Control-Change C({0}) Param-{1}", chan + 1, param, page);
|
|
}
|
|
res = regexPbEventID.Match(eventId);
|
|
if (res.Success)
|
|
{
|
|
uint page = uint.Parse(res.Groups["page"].Value);
|
|
byte chan = byte.Parse(res.Groups["chan"].Value);
|
|
return string.Format("Page {1} => PitchBend C({0})", chan + 1, page);
|
|
}
|
|
res = regexNoteEventID.Match(eventId);
|
|
if (res.Success)
|
|
{
|
|
uint page = uint.Parse(res.Groups["page"].Value);
|
|
byte chan = byte.Parse(res.Groups["chan"].Value);
|
|
byte note = byte.Parse(res.Groups["note"].Value);
|
|
return string.Format("Page {2} => Note C({0}) Note-{1}", chan + 1, note, page);
|
|
}
|
|
return eventId;
|
|
}
|
|
|
|
IFeedbackInfo IEventProvider.GetFeedbackInfo(string eventId)
|
|
{
|
|
if (!eventlist.ContainsKey(eventId))
|
|
return null;
|
|
|
|
return new midifeedbackinfo(this, eventlist[eventId]);
|
|
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
#region IDisposable implementation
|
|
|
|
bool disposed = false;
|
|
|
|
~MidiEventProvider()
|
|
{
|
|
Dispose();
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
if (disposed)
|
|
return;
|
|
disposed = true;
|
|
//AlsaSeqLib.Close();
|
|
midiport.Close();
|
|
|
|
}
|
|
#endregion
|
|
|
|
public void Save(System.Xml.XmlElement parent)
|
|
{
|
|
System.Xml.XmlElement el = parent.OwnerDocument.CreateElement("Midi");
|
|
parent.AppendChild(el);
|
|
el.SetAttribute("maxpage", maxpage.ToString());
|
|
el.SetAttribute("pageUpCC", pageUpCC.ToString());
|
|
el.SetAttribute("pageDownCC", pageDownCC.ToString());
|
|
el.SetAttribute("fourteenbits", use14b ? "true" : "false");
|
|
el.SetAttribute("max14b", max14bValue.ToString());
|
|
|
|
System.Xml.XmlElement xmlEl;
|
|
foreach (MidiControler dev in knowndevices.Values)
|
|
{
|
|
el.AppendChild(xmlEl = parent.OwnerDocument.CreateElement("MidiDev"));
|
|
xmlEl.SetAttribute("name", dev.Name);
|
|
xmlEl.SetAttribute("feedback", dev.HasFeedback.ToString());
|
|
}
|
|
|
|
foreach (byte ch in unpaginatedchannels)
|
|
{
|
|
el.AppendChild(xmlEl = parent.OwnerDocument.CreateElement("UPC"));
|
|
xmlEl.SetAttribute("ch", ch.ToString());
|
|
}
|
|
|
|
}
|
|
|
|
public void Load(System.Xml.XmlElement el)
|
|
{
|
|
if (el == null)
|
|
return;
|
|
maxpage = uint.Parse(el.TryGetAttribute("maxpage", "8"));
|
|
pageUpCC = uint.Parse(el.TryGetAttribute("pageUpCC", "127"));
|
|
pageDownCC = uint.Parse(el.TryGetAttribute("pageDownCC", "126"));
|
|
use14b = el.TryGetAttribute("fourteenbits", string.Empty).Equals("true");
|
|
max14bValue = int.Parse(el.TryGetAttribute("max14b", "255"));
|
|
|
|
foreach (var xd in el.GetElementsByTagName("MidiDev"))
|
|
{
|
|
System.Xml.XmlElement xdev = xd as System.Xml.XmlElement;
|
|
string name = xdev.GetAttribute("name");
|
|
if (!knowndevices.ContainsKey(name))
|
|
knowndevices.Add(name, new MidiControler(name));
|
|
knowndevices[name].HasFeedback = bool.Parse(xdev.TryGetAttribute("feedback", "false"));
|
|
}
|
|
unpaginatedchannels.Clear();
|
|
foreach (var xu in el.GetElementsByTagName("UPC"))
|
|
{
|
|
System.Xml.XmlElement xupc = xu as System.Xml.XmlElement;
|
|
unpaginatedchannels.Add(byte.Parse(xupc.GetAttribute("ch")));
|
|
}
|
|
|
|
AutoConnect();
|
|
}
|
|
|
|
|
|
class internalEventDesc
|
|
{
|
|
|
|
readonly string internalName;
|
|
bool bound = false;
|
|
readonly uint page;
|
|
readonly int midiEvCode;
|
|
|
|
readonly midiFeedbackSender fbSender;
|
|
|
|
public bool Bound
|
|
{
|
|
get
|
|
{
|
|
return bound;
|
|
}
|
|
set
|
|
{
|
|
bound = value;
|
|
}
|
|
}
|
|
|
|
public string InternalName
|
|
{
|
|
get
|
|
{
|
|
return internalName;
|
|
}
|
|
}
|
|
|
|
public uint Page
|
|
{
|
|
get
|
|
{
|
|
return page;
|
|
}
|
|
}
|
|
|
|
public int MidiEvCode
|
|
{
|
|
get
|
|
{
|
|
return midiEvCode;
|
|
}
|
|
}
|
|
|
|
public internalEventDesc(string _id, uint _page, int _evHCode, midiFeedbackSender _evsender)
|
|
{
|
|
internalName = _id;
|
|
page = _page;
|
|
midiEvCode = _evHCode;
|
|
fbSender = _evsender;
|
|
}
|
|
|
|
int lastknownvalue = -1;
|
|
|
|
public int LastKnownValue
|
|
{
|
|
get
|
|
{
|
|
return lastknownvalue;
|
|
}
|
|
set
|
|
{
|
|
lastknownvalue = value;
|
|
}
|
|
}
|
|
|
|
bool nofbflag = false;
|
|
|
|
public void SendFeedback()
|
|
{
|
|
if (fbSender != null && !nofbflag)
|
|
fbSender.SendFeedback(lastknownvalue);
|
|
}
|
|
|
|
public void CallEvent(EventManagerCallback callback, EventData evData)
|
|
{
|
|
nofbflag = true;
|
|
callback(evData);
|
|
nofbflag = false;
|
|
}
|
|
}
|
|
|
|
abstract class midiFeedbackSender
|
|
{
|
|
public abstract void SendFeedback(int value);
|
|
}
|
|
|
|
class midiCCFbSender : midiFeedbackSender
|
|
{
|
|
readonly MidiEventProvider prov;
|
|
|
|
AlsaSeqLib.snd_seq_event_t ev;
|
|
AlsaSeqLib.snd_seq_event_t ev2;
|
|
|
|
public midiCCFbSender(MidiEventProvider _prov, byte _chan, uint _param)
|
|
{
|
|
prov = _prov;
|
|
ev = new AlsaSeqLib.snd_seq_event_t();
|
|
ev.type = AlsaSeqLib.snd_seq_event_type_t.SND_SEQ_EVENT_CONTROLLER;
|
|
ev.data_ev_ctrl.channel = _chan;
|
|
ev.data_ev_ctrl.param = _param;
|
|
ev2 = ev;
|
|
ev2.data_ev_ctrl.param += 32;
|
|
}
|
|
public override void SendFeedback(int value)
|
|
{
|
|
if (prov.use14b && ev.data_ev_ctrl.param < 32)
|
|
{
|
|
value = value * prov.max14bValue / 255;
|
|
ev.data_ev_ctrl.value = value >> 7;
|
|
ev2.data_ev_ctrl.value = value & 0xFF;
|
|
prov.SendEvent(ev);
|
|
prov.SendEvent(ev2);
|
|
}
|
|
else
|
|
{
|
|
ev.data_ev_ctrl.value = value * 127 / 255;
|
|
prov.SendEvent(ev);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
class midiPBFbSender : midiFeedbackSender
|
|
{
|
|
readonly MidiEventProvider prov;
|
|
|
|
AlsaSeqLib.snd_seq_event_t ev;
|
|
|
|
public midiPBFbSender(MidiEventProvider _prov, byte _chan)
|
|
{
|
|
prov = _prov;
|
|
ev = new AlsaSeqLib.snd_seq_event_t();
|
|
ev.type = AlsaSeqLib.snd_seq_event_type_t.SND_SEQ_EVENT_PITCHBEND;
|
|
ev.data_ev_ctrl.channel = _chan;
|
|
|
|
}
|
|
public override void SendFeedback(int value)
|
|
{ // value = ((evS.data_ev_ctrl.value + 7000) * 255 / 14000);
|
|
|
|
ev.data_ev_ctrl.value = value * 14000 / 255 - 7000;
|
|
prov.SendEvent(ev);
|
|
}
|
|
}
|
|
|
|
class midifeedbackinfo : IFeedbackInfo
|
|
{
|
|
MidiEventProvider prov;
|
|
readonly internalEventDesc iev;
|
|
|
|
public midifeedbackinfo(MidiEventProvider _prov, internalEventDesc _iev)
|
|
{
|
|
prov = _prov;
|
|
iev = _iev;
|
|
}
|
|
|
|
#region IFeedbackInfo implementation
|
|
bool IFeedbackInfo.FeedBack(byte data)
|
|
{
|
|
|
|
iev.LastKnownValue = data;
|
|
|
|
if (prov.CurrentPage == iev.Page || iev.Page == 0)
|
|
{
|
|
iev.SendFeedback();
|
|
foreach (AlsaSeqLib.Port src in prov.feedbacksources)
|
|
{
|
|
int lnvk = CombineHash(src.SrcId, iev.MidiEvCode);
|
|
if (iev.LastKnownValue != -1)
|
|
prov.lastValueOfSrc[lnvk] = (byte)iev.LastKnownValue;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
#endregion
|
|
}
|
|
|
|
public class MidiControler
|
|
{
|
|
string name;
|
|
|
|
public string Name { get { return name; } }
|
|
|
|
public bool HasFeedback { get; set; }
|
|
|
|
readonly List<AlsaSeqLib.Port> connected = new List<AlsaSeqLib.Port>();
|
|
|
|
public List<AlsaSeqLib.Port> ConnectedPorts
|
|
{
|
|
get { return connected; }
|
|
}
|
|
|
|
public MidiControler(string _name)
|
|
{
|
|
name = _name;
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|