static void __benchMark6(short refNum)
{
long i, d;
d = MidiGetTime() - 500;
for (i = 1; i <= 500; i++) {
MidiTask(emptyProcess, d + i, refNum, 500, 0, 0);
}
d = MidiGetTime() - 10;
for (i = 1; i <= 10; i++) {
MidiTask(emptyProcess, d + i, refNum, 10, 0, 0);
}
}
/* ------------------------------------------------------------------------- */
void MSALARMAPI ReceiveEvents(short r)
{
if (MidiTask(ReceivePolling,MidiGetTime(),r,(long)MidiGetInfo(r),0,0))
MidiSetRcvAlarm (r, 0);
else
MidiFlushEvs(r);
}
static void __benchMark8(short refNum)
{
long i, dx = MidiGetTime() - 16;
for (i = 1; i <= 16; i++) {
MidiTask(emptyProcess, dx + i, refNum, 16, 0, 0);
}
}
static void __benchMark7 (short refNum)
{
long i, d;
d = MidiGetTime() - 250;
for (i = 1; i <= 250; i++) {
MidiTask(emptyProcess, d + i, refNum, 250, 0, 0);
}
d = MidiGetTime() - 176;
for (i = 1; i <= 176; i++) {
MidiTask(emptyProcess, d + i, refNum, 176, 0, 0);
}
d = MidiGetTime() - 48;
for (i = 1; i <= 48; i++) {
MidiTask(emptyProcess, d + i, refNum, 48, 0, 0);
}
}
//_______________________________________________________________________
static pascal void CheckFifo (long date, short refNum, long a1, long a2, long a3)
{
SCCPtr scc = (SCCPtr)a1;
MidiEvPtr e = scc->seq.first;
if (e && (MidiGetTime() - Date(e) > 1000))
ClearSeq (&scc->seq);
if(scc->seq.last == (MidiEvPtr)&scc->seq.first)
scc->MTPOutPort = -1;
scc->checkTask= MidiTask (CheckFifo, date + 500, refNum, a1, a2, a3);
}
/* ------------------------------------------------------------------------- */
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);
}
static void __benchMark9(short refNum)
{
long i, d = MidiGetTime() - 16;
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);
}
}
}
/* --------------------------------------------------------
Application receive alarm
-------------------------------------------------------- */
void MSALARMAPI ReceiveEvents ( short r)
{
MidiEvPtr e;
unsigned long d;
while (e = MidiGetEv(r)) {
d = Date(e) + MSParam[kDelay];
if ( (MSParam[kChan]!=0) && (MSParam[kChan]!=Chan(e)+1) )
MidiFreeEv(e);
else if ( EvType(e) == typeNote ) {
if( !MidiTask(EchoTask,d,r,(long)e,0,0))
MidiFreeEv(e);
}
else if ( Vel(e) > 0 ) {
EvType(e) = typeNote;
Dur(e) = 100;
if( !MidiTask(EchoTask,d,r,(long)e,0,0))
MidiFreeEv(e);
}
else MidiFreeEv(e);
}
}
//_______________________________________________________________________
static Boolean GetByte (SCCPtr scc, Byte *c)
{
if (MidiStreamGetByte(&scc->xmt, c))
return true;
else {
MidiEvPtr e = Pop(&scc->seq);
if (e) {
e = MidiStreamPutEvent (&scc->xmt, e);
if (e) MidiTask (KeyOffTask, Date(e), 0, (long)scc, (long)e, 0);
return MidiStreamGetByte(&scc->xmt, c);
}
}
return false;
}
MSALARMAPI void PlayTask (long date, short r, TSequencer * s, MidiEvPtr e, long d)
{
d = Date(e);
while (e && (Date(e) == d)) {
MidiSendAt(r, MidiCopyEv(e), date+10);
e = Link(e);
}
if (e) {
s->playtask = MidiTask((TaskPtr)PlayTask, date+Date(e)-d, r, (long)s, (long)e, 0);
} else {
s->playtask = 0;
s->state = idle;
}
}
static pascal void AccProcess(long d, short refNum, long a1, long a2, long a3)
{
short i;
for (i = 0; i <= 15; i++) {
MidiEvPtr e = MidiNewEv(typeNote);
if (e) {
Pitch(e) = 60;
Vel(e) = 80;
Dur(e) = 16;
Chan(e) = i;
}
MidiSend (refNum, e);
}
MidiTask (AccProcess, d + 32, refNum, a1, a2, a3);
}
//_______________________________________________________________________
static void RcvAlarm (short refNum)
{
DrvMemPtr mem = GetData ();
Ev2StreamPtr f = &mem->outFifo;
MidiEvPtr off, e = MidiGetEv (refNum);
Byte c;
while (e) {
off = MidiStreamPutEvent (f, e);
while (MidiStreamGetByte (f, &c)) {
write (mem->devId, &c, 1);
}
if (off) MidiTask (KeyOffTask, Date(off), refNum, (long)off, (long)mem, 0);
e = MidiGetEv (refNum);
}
}
/* -----------------------------------------------------------------------------*/
static pascal void GenProcess(long d, short ref, long start, long num, long freq)
{
short i, adv = 5;
for (i = 0; i <= 15; i++) {
MidiEvPtr e = MidiNewEv (typeKeyPress);
if (e) {
Pitch(e) = 60;
Vel(e) = 80;
Chan(e) = i;
MidiSendAt (ref, e, start + adv + num * 1000 / freq);
num++;
}
}
genTask = MidiTask (GenProcess, start + num * 1000 / freq, ref, start, num, freq);
}
//_________________________________________________________
static void SendSmallEv(SlotPtr slot, MidiEvPtr e, sendState* state)
{
MIDIPacketList* pktlist = (MIDIPacketList*)state->packetBuffer;
MIDIPacket* packet = MIDIPacketListInit(pktlist);
unsigned char * ptr = state->evBuffer;
OSErr err;
int n = 0;
e = MidiStreamPutEvent (&state->outsmall, e);
if (e) MidiTask (KOffTask, Date(e), gRefNum, (long)e, (long)slot, 0); // typeNote
while (MidiStreamGetByte (&state->outsmall, ptr++)) {n++;}
MIDIPacketListAdd(pktlist,sizeof(state->packetBuffer),packet,MIDIGetCurrentHostTime(),n,state->evBuffer);
err = MIDISend(slot->port,slot->dest,pktlist);
if (err != noErr) fprintf(stderr, "MIDISend : error %ld\n", err);
}
/* --------------------------------------------------------
Real time echo management task
-------------------------------------------------------- */
void MSALARMAPI EchoTask( long d,short ref,long el,long a2, long a3)
{
MidiEvPtr e;
short v,p;
e= (MidiEvPtr)el;
v = Vel(e)+MSParam[kVel];
p = Pitch(e)+MSParam[kPitch];
if ( ((v>0)&&(v<128)) && ((p>=0)&&(p<128)) ) {
Vel(e) = v;
Pitch(e) = p;
MidiSendAt(ref, MidiCopyEv(e), d);
if( !MidiTask(EchoTask, d+MSParam[kDelay], ref, el, 0, 0))
MidiFreeEv(e);
}
else MidiFreeEv(e);
}
void MidiInputDeviceMidiShare::ReceiveEvents(short ref)
{
MidiInputDeviceMidiShare* driver = (MidiInputDeviceMidiShare*)MidiGetInfo(ref);
MidiEvPtr ev;
while ((ev = MidiGetEv(ref)))
switch(EvType(ev)) {
case typeCtrlChange:
if (MidiGetField(ev,0) == 0)
driver->DispatchBankSelectMsb(MidiGetField(ev,0),Chan(ev));
else if (MidiGetField(ev,0) == 32)
driver->DispatchBankSelectLsb(MidiGetField(ev,0),Chan(ev));
else
driver->DispatchControlChange(MidiGetField(ev,0),MidiGetField(ev,0),Chan(ev));
MidiFreeEv(ev);
break;
case typePitchWheel:
driver->DispatchPitchbend(((MidiGetField(ev,0)+(MidiGetField(ev,1) << 7)) - 8192),Chan(ev));
MidiFreeEv(ev);
break;
case typeNote:
driver->DispatchNoteOn(Pitch(ev),Vel(ev),Chan(ev));
MidiTask(KeyOffTask,Date(ev)+Dur(ev),ref,(long)ev,0,0);
break;
case typeKeyOn:
if (Vel(ev) > 0)
driver->DispatchNoteOn(Pitch(ev),Vel(ev),Chan(ev));
else
driver->DispatchNoteOff(Pitch(ev),Vel(ev),Chan(ev));
MidiFreeEv(ev);
break;
case typeKeyOff:
driver->DispatchNoteOff(Pitch(ev),Vel(ev),Chan(ev));
MidiFreeEv(ev);
break;
}
}
//_______________________________________________________________________
Boolean OpenLine (MtpDrvPtr data)
{
SCCPtr scc = &data->scc;
if (__OpenLine()) {
if( data->powerMgr) PwMngON;
SetData (scc);
MidiParseInit (&scc->rcv, data->rTbl, data->s2t);
MidiStreamInit (&scc->xmt, data->lTbl);
scc->seq.last = (MidiEvPtr)&scc->seq.first;
scc->refNum = data->refNum;
LockedCall(SetupPort());
scc->checkTask = MidiTask (CheckFifo, MidiGetTime()+100, data->refNum, (long)scc, 0, 0);
scc->state = true;
return true;
}
return false;
}
static pascal void keyOnProcess(long d, short refNum, long delay, long model, long a3)
{
MidiSendAt(refNum, MidiCopyEv((MidiEvPtr)model), d + 7);
MidiTask (keyOnProcess, d + delay, refNum, delay, model, a3);
}
static pascal void emptyProcess(long d, short refNum, long a1, long a2, long a3)
{
MidiTask (emptyProcess, d + a1, refNum, a1, a2, a3);
}
static void __benchMark12(short refNum)
{
MidiConnect(refNum, 0, true);
MidiTask (AccProcess, MidiGetTime(), refNum, 0, 0, 0);
}
MSALARMAPI void LoopTask (long date, short r, TSequencer * s, long dur, long unused)
{
PlaySeq(s);
s->looptask = MidiTask((TaskPtr)LoopTask, date+dur, r, (long)s, dur, 0);
}
/*
* fluid_midishare_midi_driver_receive
*/
static void fluid_midishare_midi_driver_receive(short ref)
{
fluid_midishare_midi_driver_t* dev = (fluid_midishare_midi_driver_t*)MidiGetInfo(ref);
fluid_midi_event_t new_event;
MidiEvPtr e;
int count, i;
while ((e = MidiGetEv (ref)))
{
switch (EvType (e))
{
case typeNote:
/* Copy the data to fluid_midi_event_t */
fluid_midi_event_set_type(&new_event, NOTE_ON);
fluid_midi_event_set_channel(&new_event, Chan(e));
fluid_midi_event_set_pitch(&new_event, Pitch(e));
fluid_midi_event_set_velocity(&new_event, Vel(e));
/* and send it on its way to the router */
(*dev->driver.handler)(dev->driver.data, &new_event);
#if defined(MACINTOSH) && defined(MACOS9)
MidiTask(dev->upp_task_ptr, MidiGetTime()+Dur(e), ref, (long)e, 0, 0);
#else
MidiTask(fluid_midishare_keyoff_task, MidiGetTime()+Dur(e), ref, (long)e, 0, 0);
#endif
/* e gets freed in fluid_midishare_keyoff_task */
continue;
case typeKeyOn:
/* Copy the data to fluid_midi_event_t */
fluid_midi_event_set_type(&new_event, NOTE_ON);
fluid_midi_event_set_channel(&new_event, Chan(e));
fluid_midi_event_set_pitch(&new_event, Pitch(e));
fluid_midi_event_set_velocity(&new_event, Vel(e));
break;
case typeKeyOff:
/* Copy the data to fluid_midi_event_t */
fluid_midi_event_set_type(&new_event, NOTE_OFF);
fluid_midi_event_set_channel(&new_event, Chan(e));
fluid_midi_event_set_pitch(&new_event, Pitch(e));
fluid_midi_event_set_velocity(&new_event, Vel(e)); /* release vel */
break;
case typeCtrlChange:
/* Copy the data to fluid_midi_event_t */
fluid_midi_event_set_type(&new_event, CONTROL_CHANGE);
fluid_midi_event_set_channel(&new_event, Chan(e));
fluid_midi_event_set_control(&new_event, MidiGetField(e,0));
fluid_midi_event_set_value(&new_event, MidiGetField(e,1));
break;
case typeProgChange:
/* Copy the data to fluid_midi_event_t */
fluid_midi_event_set_type(&new_event, PROGRAM_CHANGE);
fluid_midi_event_set_channel(&new_event, Chan(e));
fluid_midi_event_set_program(&new_event, MidiGetField(e,0));
break;
case typePitchWheel:
/* Copy the data to fluid_midi_event_t */
fluid_midi_event_set_type(&new_event, PITCH_BEND);
fluid_midi_event_set_channel(&new_event, Chan(e));
fluid_midi_event_set_value(&new_event, ((MidiGetField(e,0)
+ (MidiGetField(e,1) << 7))
- 8192));
break;
case typeSysEx:
count = MidiCountFields (e);
/* Discard empty or too large SYSEX messages */
if (count == 0 || count > FLUID_MIDI_PARSER_MAX_DATA_SIZE)
{
MidiFreeEv (e);
continue;
}
/* Copy SYSEX data, one byte at a time */
for (i = 0; i < count; i++)
dev->sysexbuf[i] = MidiGetField (e, i);
fluid_midi_event_set_sysex (&new_event, dev->sysexbuf, count, FALSE);
break;
default:
MidiFreeEv (e);
continue;
}
MidiFreeEv (e);
/* Send the MIDI event */
(*dev->driver.handler)(dev->driver.data, &new_event);
}
}
static void __benchMark4(short refNum)
{ MidiTask (emptyProcess, MidiGetTime(), refNum, 1, 0, 0); }
