/* ------------------------------------------------------------------------- */
void InstallFilter( short refNum, MidiFilterPtr filter )
{
short i;
if (!filter) return;
for (i = 0 ; i < 256 ; i++ )
{
MidiAcceptType(filter,i,true);
MidiAcceptPort(filter,i,true);
}
for (i = 0 ; i < 16 ; i++ ) MidiAcceptChan(filter,i,true);
MidiSetFilter(refNum, filter);
}
/*____________________________________________________________________*/
int Open (void)
{
refNum= MidiOpen( ApplName);
if (refNum > 0) {
myFilterPtr = NewFilter();
if (!myFilterPtr) {
Close ();
return false;
}
MidiConnect( refNum, refNum, true);
MidiSetFilter( refNum, myFilterPtr);
return true;
}
return false;
}
void InstallFilter (short aRefNum, MidiFilterPtr aFilter)
{
short i;
for (i = 0; i<256; i++) /* initialise the filter : */
{
MidiAcceptType(aFilter,i,true); /* accept every MidiShare events */
MidiAcceptPort(aFilter,i,true); /* on every Midi ports */
}
for (i = 0; i<16; i++)
MidiAcceptChan(aFilter,i,true); /* on every Midi channels */
MidiAcceptType(aFilter, typeActiveSens,false); /* reject active sensing events */
MidiSetFilter( aRefNum, aFilter ); /* install the filter */
}
/* ------------------------------------------------------------------------- */
pascal void InstallFilter( short refNum, MidiFilterPtr filter )
{
short i;
if (!myFilter) return;
for (i = 0 ; i < 256 ; i++ )
{
MidiAcceptType(myFilter,i,false);
MidiAcceptPort(myFilter,i,true);
}
for (i = 0 ; i < 16 ; i++ ) MidiAcceptChan(myFilter,i,true);
MidiAcceptType(myFilter,typeKeyOn, true);
MidiAcceptType(myFilter,typeKeyOff, true);
MidiAcceptType(myFilter,typeCtrlChange, true);
MidiAcceptType(myFilter,typePitchWheel, true);
MidiSetFilter(refNum, myFilter);
}
/* ----------------------------------------------------------------------------
For incoming events filtering
---------------------------------------------------------------------------- */
void InstallFilter(void) {
short i;
myFilter = MidiNewFilter();
if (myFilter) {
for (i=0; i<256; i++) {
MidiAcceptType(myFilter,i,false);
MidiAcceptPort(myFilter,i,true);
}
MidiAcceptType(myFilter,typeNote,true);
MidiAcceptType(myFilter,typeKeyOn,true);
for (i=0; i<16; i++) MidiAcceptChan(myFilter,i,true);
MidiSetFilter(myRefNum,myFilter);
}
}
/**
* Create MidiShare input device for LinuxSampler.
*
* @param AutoConnectPortID - (optional) Alsa client and port ID of a
* MIDI source we should auto connect to
* (e.g. "64:0")
* @throws MidiInputException if initialization failed
*/
MidiInputDeviceMidiShare::MidiInputDeviceMidiShare(char* AutoConnectPortID) : MidiInputDevice(MidiInputDevice::type_midishare)
{
if (!MidiShare())
throw MidiInputException("MidiShare not installed");
#if defined(MIDISHARE_DRIVER)
OpenDriver();
#else
OpenAppl();
#endif
hMidiFilter = MidiNewFilter();
if (hMidiFilter == 0) {
MidiClose(hRefnum);
throw MidiInputException("MidiShare filter can not be allocated");
}
for (int i = 0 ; i < 256; i++) {
MidiAcceptPort(hMidiFilter, i, 1); /* accept all ports */
MidiAcceptType(hMidiFilter, i, 0); /* reject all types */
}
for (int i = 0 ; i < 16; i++) {
MidiAcceptChan(hMidiFilter, i, 1); /* accept all chan */
}
/* accept only the following types */
MidiAcceptType(hMidiFilter, typeNote, 1);
MidiAcceptType(hMidiFilter, typeKeyOn, 1);
MidiAcceptType(hMidiFilter, typeKeyOff, 1);
MidiAcceptType(hMidiFilter, typeCtrlChange, 1);
//MidiAcceptType(hMidiFilter, typeProgChange, 1);
MidiAcceptType(hMidiFilter, typePitchWheel, 1);
/* set the filter */
MidiSetFilter(hRefnum, hMidiFilter);
MidiSetRcvAlarm(hRefnum,ReceiveEvents);
MidiSetApplAlarm(hRefnum,ApplAlarm);
MidiSetInfo(hRefnum,this);
MidiConnect(0,hRefnum,true);
}
//_______________________________________________________________________
static void SetupMidi (char *name, DrvMemPtr mem)
{
MidiFilterPtr filter;
short ref = MidiOpen (name);
if (ref < 0) FatalError ("MidiOpen failed !");
mem->refNum = ref;
filter = MidiNewFilter ();
if (!filter) FatalError ("MidiNewFilter failed !");
mem->filter = filter;
SetupFilter (filter);
MidiSetFilter (ref, filter);
MidiParseInitMthTbl (mem->inMthd);
MidiParseInitTypeTbl(mem->inTypes);
MidiParseInit (&mem->inFifo, mem->inMthd, mem->inTypes);
MidiStreamInitMthTbl (mem->outMthd);
MidiStreamInit (&mem->outFifo, mem->outMthd);
MidiSetRcvAlarm (ref, RcvAlarm);
}
/*
* new_fluid_midishare_midi_driver
*/
fluid_midi_driver_t*
new_fluid_midishare_midi_driver(fluid_settings_t* settings,
handle_midi_event_func_t handler,
void* data)
{
fluid_midishare_midi_driver_t* dev;
int i;
/* not much use doing anything */
if (handler == NULL) {
FLUID_LOG(FLUID_ERR, "Invalid argument");
return NULL;
}
/* allocate the device */
dev = FLUID_NEW(fluid_midishare_midi_driver_t);
if (dev == NULL) {
FLUID_LOG(FLUID_ERR, "Out of memory");
return NULL;
}
FLUID_MEMSET(dev, 0, sizeof(fluid_midishare_midi_driver_t));
dev->driver.handler = handler;
dev->driver.data = data;
/* register to MidiShare as Application or Driver */
#if defined(MIDISHARE_DRIVER)
if (!fluid_midishare_open_driver(dev)) goto error_recovery;
#else
if (!fluid_midishare_open_appl(dev)) goto error_recovery;
#endif
/*MidiSetInfo(dev->refnum, dev->router->synth); */
MidiSetInfo(dev->refnum, dev);
dev->filter = MidiNewFilter();
if (dev->filter == 0) {
FLUID_LOG(FLUID_ERR, "Can not allocate MidiShare filter");
goto error_recovery;
}
for (i = 0 ; i < 256; i++) {
MidiAcceptPort(dev->filter, i, 1); /* accept all ports */
MidiAcceptType(dev->filter, i, 0); /* reject all types */
}
for (i = 0 ; i < 16; i++) {
MidiAcceptChan(dev->filter, i, 1); /* accept all chan */
}
/* accept only the following types */
MidiAcceptType(dev->filter, typeNote, 1);
MidiAcceptType(dev->filter, typeKeyOn, 1);
MidiAcceptType(dev->filter, typeKeyOff, 1);
MidiAcceptType(dev->filter, typeCtrlChange, 1);
MidiAcceptType(dev->filter, typeProgChange, 1);
MidiAcceptType(dev->filter, typePitchWheel, 1);
MidiAcceptType(dev->filter, typeSysEx, 1);
/* set the filter */
MidiSetFilter(dev->refnum, dev->filter);
dev->status = FLUID_MIDI_READY;
return (fluid_midi_driver_t*) dev;
error_recovery:
delete_fluid_midishare_midi_driver((fluid_midi_driver_t*) dev);
return NULL;
}
