//_______________________________________________________________________
static Boolean connect (short ref)
{
MidiName name = MidiGetName(ref);
if (!name) return false;
if (gAddr.SetAddress (name)) {
MidiConnect (gSrc, ref, true);
return true;
}
if (strlen(name) >= 31) {
MidiConnect (gSrc, ref, true);
return true;
}
return false;
}
void test16 ()
{
printf("\n\n<TEST 16> send a Lyric to 'msDisplay'\n");
printf("YOU NEED TO LAUNCH 'msDisplay' FOR THIS TEST!!!\n");
DebugStr ("--> use g or G to send a Lyric to 'msDisplay' and go to the next test\n");
if (MidiGetNamedAppl ("msDisplay") < 0) {
printf("You need to launch msDisplay for this test\n");
} else {
MidiConnect(0, MidiGetNamedAppl ("msDisplay"), false);
MidiConnect(ourRefNum, MidiGetNamedAppl ("msDisplay"), true);
sendLyric("Hello");
}
}
void test10 ()
{
printf("\n\n<TEST 10> connect the output of 'MidiShare Tutorial' to 'MidiShare'\n");
DebugStr ("--> use g or G to make the connection and go to the next test\n");
MidiConnect(ourRefNum, 0, true);
}
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 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);
}
/* ----------------------------------------------------------------------------
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;
}
/* ------------------------------------------------------------------------- */
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);
}
static void __benchMark10(short refNum)
{
long i, d = MidiGetTime() - 16;
MidiConnect(refNum, 0, true);
for (i = 1; i <= 16; i++) {
MidiEvPtr e = MidiNewEv (typeKeyOn);
if (e) {
Chan(e) = i - 1;
MidiTask (keyOnProcess, d + i, refNum, 16, (long)e, 0);
}
}
}
/*____________________________________________________________________*/
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 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);
}
/**
* 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);
}
/*
* 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;
}
/* ------------------------------------------------------------------------- */
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;
}
static void unselect_dst(GtkWidget *widget, gint row, gint column, GdkEventButton *event, gpointer data)
{
if (!gUpdateFlag) MidiConnect(row2ref(gCurRow), row2ref(row), 0);
}
static void __benchMark12(short refNum)
{
MidiConnect(refNum, 0, true);
MidiTask (AccProcess, MidiGetTime(), refNum, 0, 0, 0);
}
/*
* fluid_midishare_wakeup
*/
static void fluid_midishare_wakeup (short r)
{
MidiConnect (MidiShareDrvRef, r, true);
MidiConnect (r, MidiShareDrvRef, true);
}
void StartGen (short f)
{
genRef = MidiOpen(GenName);
MidiConnect (genRef, 0, true);
GenProcess (MidiGetTime(), genRef, MidiGetTime(), 0, f * 100);
}
void MidiInputDeviceMidiShare::WakeUp(short r)
{
MidiConnect(MidiShareDrvRef, r, true);
MidiConnect(r, MidiShareDrvRef, true);
}
