/* ------------------------------------------------------------------------- */
int InitMidi()
{
if ( !MidiShare())
{
sprintf (string_Last_Order,"MidiShare not available\n");
}
InitTblLibEv();
myRefNum = MidiOpen(AppliName);
if (myRefNum < 0) {sprintf(string_Last_Order,"MidiOpen failed!");}
MidiSetRcvAlarm(myRefNum,ReceiveEvents);
MidiConnect(0, myRefNum, true);//in
MidiConnect(myRefNum,0,true);//out
myFilter = MidiNewFilter();
InstallFilter( myRefNum,myFilter ); //filtrage
return(0);
}
/* ----------------------------------------------------------------------------
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);
}
/* ------------------------------------------------------------------------- */
Boolean SetUpMidi(void)
{
char buff[32], *name;
InitTblLibEv();
if ( !MidiShare()) {
printf ("MidiShare not available\n");
return false;
}
myRefNum = MidiOpen(AppliName);
if ( myRefNum == MIDIerrSpace ){
printf ( "Too much MidiShare client applications\n");
return false;
}
MidiSetRcvAlarm(myRefNum,ReceiveEvents);
MidiConnect( 0, myRefNum, true);
myFilter = MidiNewFilter();
InstallFilter( myRefNum, myFilter);
return true;
}
void test21 ()
{
long n;
printf("\n\n<TEST 21> record and playback a sequence\n");
DebugStr ("--> use g or G to start recording\n");
ourSequence = MidiNewSeq();
ourFilter = MidiNewFilter();
InstallFilter(ourRefNum,ourFilter);
MidiFlushEvs(ourRefNum);
MidiSetRcvAlarm(ourRefNum, record);
MidiConnect(0, ourRefNum, true);
MidiConnect(ourRefNum, 0, true);
printf("Now play on the Midi keyboard, every thing is recorded\n");
DebugStr ("--> use g or G to stop recording\n");
MidiConnect(0, ourRefNum, false);
MidiSetRcvAlarm(ourRefNum, 0);
printf (" %ld events where recorded\n", size(ourSequence));
DebugStr ("--> use g or G to play back the sequence\n");
stopFlag = 0;
if (FirstEv(ourSequence)) {
MidiCall(play, MidiGetTime(), ourRefNum, (long) FirstEv(ourSequence), 0, 0);
}
printf("Now playing the sequence\n");
DebugStr ("--> use g or G to stop play back and go to the next test\n");
stopFlag = 1;
MidiFreeSeq(ourSequence);
}
/*
* 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;
}
