/* * fluid_midishare_open_driver */ static int fluid_midishare_open_driver (fluid_midishare_midi_driver_t* dev) { /* gcc wanted me to use {0,0} to initialize the reserved[2] fields */ TDriverInfos infos = { MSHDriverName, 100, 0, { 0, 0 } }; TDriverOperation op = { fluid_midishare_wakeup, fluid_midishare_sleep, { 0, 0, 0 } }; /* register to MidiShare */ #if defined(MACINTOSH) && defined(MACOS9) dev->upp_wakeup_ptr = NewDriverPtr(fluid_midishare_wakeup); dev->upp_sleep_ptr = NewDriverPtr(fluid_midishare_sleep); op.wakeup = (WakeupPtr)dev->upp_wakeup_ptr; op.sleep = (SleepPtr)dev->upp_sleep_ptr; dev->refnum = MidiRegisterDriver(&infos, &op); if (dev->refnum < 0) { FLUID_LOG(FLUID_ERR, "Can not open MidiShare Application client"); return 0; } dev->slotRef = MidiAddSlot (dev->refnum, MSHSlotName, MidiOutputSlot); dev->upp_alarm_ptr = NewRcvAlarmPtr(fluid_midishare_midi_driver_receive); dev->upp_task_ptr = NewTaskPtr(fluid_midishare_keyoff_task); MidiSetRcvAlarm(dev->refnum, dev->upp_alarm_ptr); #else dev->refnum = MidiRegisterDriver(&infos, &op); if (dev->refnum < 0) { FLUID_LOG(FLUID_ERR, "Can not open MidiShare Application client"); return 0; } dev->slotRef = MidiAddSlot (dev->refnum, MSHSlotName, MidiOutputSlot); MidiSetRcvAlarm(dev->refnum, fluid_midishare_midi_driver_receive); #endif return 1; }
//_______________________________________________________________________ void CnxInit (short ref) { gSrc = ref; MidiSetRcvAlarm (ref, rcvalarm); MidiSetApplAlarm (ref, applalarm); start (); }
void RecSeq(TSequencer * s) { StopSeq(s); printf("Record\n"); s->state = recording; MidiSetRcvAlarm(s->ref, RecRcv); }
void test20 () { printf("\n\n<TEST 20> transpose and delay in real-time\n"); DebugStr ("--> use g or G to start transposing incoming events\n"); MidiFlushEvs(ourRefNum); MidiSetRcvAlarm(ourRefNum, transposeAndDelay); MidiConnect(0, ourRefNum, true); MidiConnect(ourRefNum, 0, true); printf("Now play on the Midi keyboard, notes are transposed and delayed\n"); DebugStr ("--> use g or G to stop transposing events and go to the next test\n"); MidiConnect(0, ourRefNum, false); MidiSetRcvAlarm(ourRefNum, 0); }
void test19 () { printf("\n\n<TEST 19> thru incoming events\n"); DebugStr ("--> use g or G to start thruing incoming events\n"); MidiFlushEvs(ourRefNum); MidiSetRcvAlarm(ourRefNum, thru); MidiConnect(0, ourRefNum, true); MidiConnect(ourRefNum, 0, true); printf("Now play on the Midi keyboard\n"); DebugStr ("--> use g or G to stop thruing incoming events and go to the next test\n"); MidiConnect(0, ourRefNum, false); MidiSetRcvAlarm(ourRefNum, 0); }
/* ------------------------------------------------------------------------- */ void MSALARMAPI ReceiveEvents(short r) { if (MidiTask(ReceivePolling,MidiGetTime(),r,(long)MidiGetInfo(r),0,0)) MidiSetRcvAlarm (r, 0); else MidiFlushEvs(r); }
void MidiInputDeviceMidiShare::OpenAppl() { hRefnum = MidiOpen(MSHDriverName); if (hRefnum < 0) { throw MidiInputException("MidiShare client can not be opened"); } MidiSetRcvAlarm(hRefnum,ReceiveEvents); MidiSetApplAlarm(hRefnum,ApplAlarm); }
/* -----------------------------------------------------------------------------*/ Boolean SetupMidi(void) { myRefNum = MidiOpen (ApplName); if (myRefNum == MIDIerrSpace) return false; chgDriver = chgCon = false; MidiSetApplAlarm (myRefNum, ApplAlarm); MidiSetRcvAlarm (myRefNum, RcvAlarm); return true; }
/* ------------------------------------------------------------------------- */ void MSALARMAPI ReceivePolling ( long date, short r, long a, long b, long c) { long n; n= MidiCountEvs (r); if (n) { DisplayTask(r); MidiTask (ReceivePolling, date+100, r, a, 0, 0); } else MidiSetRcvAlarm (r, ReceiveEvents); }
void MidiInputDeviceMidiShare::OpenDriver() { /* gcc wanted me to use {0,0} to initialize the reserved[2] fields */ TDriverInfos infos = { MSHDriverName, 100, 0, { 0, 0 } }; TDriverOperation op = { WakeUp, Sleep, { 0, 0, 0 } }; hRefnum = MidiRegisterDriver(&infos, &op); if (hRefnum < 0) { throw MidiInputException("MidiShare driver can not be opened"); } hSlotRef = MidiAddSlot(hRefnum,MSHSlotName,MidiOutputSlot); MidiSetRcvAlarm(hRefnum,ReceiveEvents); }
//________________________________________________________________________________________ bool MS2MM(short refNum, SlotPtr slot, MidiEvPtr e) { int type = EvType(e); if ((type == typeSysEx) || (type == typeStream)) { MidiSetRcvAlarm(refNum,0); SendSysEx(slot,e); return false; }else{ SendSmallEv(slot,e,&slot->state); return true; } }
/* * fluid_midishare_open_appl */ static int fluid_midishare_open_appl (fluid_midishare_midi_driver_t* dev) { /* register to MidiShare */ #if defined(MACINTOSH) && defined(MACOS9) dev->refnum = MidiOpen(MSHDriverName); if (dev->refnum < 0) { FLUID_LOG(FLUID_ERR, "Can not open MidiShare Driver client"); return 0; } dev->upp_alarm_ptr = NewRcvAlarmPtr(fluid_midishare_midi_driver_receive); dev->upp_task_ptr = NewTaskPtr(fluid_midishare_keyoff_task); MidiSetRcvAlarm(dev->refnum, dev->upp_alarm_ptr); #else dev->refnum = MidiOpen(MSHDriverName); if (dev->refnum < 0) { FLUID_LOG(FLUID_ERR, "Can not open MidiShare Driver client"); return 0; } MidiSetRcvAlarm(dev->refnum, fluid_midishare_midi_driver_receive); MidiConnect(0,dev->refnum,true); #endif return 1; }
void StopSeq(TSequencer * s) { printf("Stop\n"); switch (s->state) { case playing : MidiForgetTask(&s->playtask); MidiForgetTask(&s->looptask); s->state = idle; break; case recording : MidiSetRcvAlarm(s->ref, NullRcv); s->state = idle; break; } }
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); }
/* ---------------------------------------------------------------------------- MidiShare setup ---------------------------------------------------------------------------- */ Boolean SetUpMidi(void) { if ( !MidiShare() ) { printf("MidiShare is not installed\n"); return false; } myRefNum = MidiOpen(AppliName); if ( myRefNum == MIDIerrSpace ) { printf("Too much MidiShare client applications\n"); return false; } MidiSetRcvAlarm(myRefNum,ReceiveEvents); InstallFilter(); MidiConnect (myRefNum, 0, true); MidiConnect (0, myRefNum, true); return true; }
//_________________________________________________________ void SendEvents2 (short refNum) { SlotPtr slot = 0; MidiEvPtr e; while ((e = MidiGetEv (refNum))) { if (!slot || (Slot(slot->refNum) != Port(e))) slot = FindSlot(gOutSlots, Port(e)); if (slot) { if (!MS2MM (refNum, slot, e)) return; // A SysEx is sent }else{ MidiFreeEv(e); } } MidiSetRcvAlarm(refNum,RcvAlarm); MidiSendIm(refNum, MidiNewEv(typeRestart)); }
/* ------------------------------------------------------------------------- */ 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); }
void OpenSeq(TSequencer * s, char * n) { midiFILE * f; int i; // initialisation s->ref = MidiOpen("msMidiPlayer"); s->state = idle; s->seq = MidiNewSeq(); s->playtask = 0; s->looptask = 0; // read the midi file f = MidiFileOpen(n, MidiFileRead); if (!f) { printf ("Error opening MidiFile %s (%d)\n", n, MidiFile_errno); CloseSeq(s); exit(MidiFile_errno); } for (i = f->ntrks; i; i--){ MixSeq( MidiFileReadTrack(f), s->seq); } if (smpte(f)) TrsfSmpteSeq(s->seq, frame_par_sec(f), ticks_par_frame(f)); else TrsfTempoSeq(s->seq, ticks_par_quarterNote(f)); if (First(s->seq)) printf("File : %s, Format : %d, Tracks : %d, Length : %d, Duration : %d\n", n, f->format, f->ntrks, LenSeq(s->seq), Date(Last(s->seq)) ); (void) MidiFileClose(f); // installation MidiSetInfo(s->ref, s); MidiSetRcvAlarm(s->ref, NullRcv); MidiConnect(s->ref, 0, 1); MidiConnect(0, s->ref, 1); }
int main(int argc, char *argv[] ) { GtkWidget *window, *vbox; char applName[256]; // Initialisations gtk_init (&argc, &argv); StripPath (argv[0], applName); CheckMidiShare (applName); gRefNum = MidiOpen(applName); MidiSetRcvAlarm (gRefNum,rcv_alarm); MidiConnect(gRefNum,0,1); MidiConnect(0,gRefNum,1); // Window definition window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), applName); gtk_container_set_border_width(GTK_CONTAINER(window), 10); vbox = gtk_vbox_new (FALSE, 10); // Add controllers add_time (vbox); add(vbox, gtk_hseparator_new()); add_buttons (vbox); gtk_container_add(GTK_CONTAINER(window), vbox); gtk_widget_show_all (window); gtk_signal_connect(GTK_OBJECT(gRun), "clicked", GTK_SIGNAL_FUNC(start_stop_action), NULL); gtk_signal_connect(GTK_OBJECT(gReset), "clicked", GTK_SIGNAL_FUNC(reset_action), NULL); // Connexion of signals gtk_signal_connect( GTK_OBJECT(window), "destroy", GTK_SIGNAL_FUNC(my_delete_action), NULL ); gtk_main (); return(0); }
/** * 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; }