void SeqDriver::procEvents() { int l1; snd_seq_event_t *evIn, evOut; bool outOfRange = false; bool unmatched = false; MidiMap* mm; do { snd_seq_event_input(seq_handle, &evIn); emit midiEvent(evIn); unmatched = true; for(l1 = 0; l1 < midiMapList->count(); l1++) { mm = midiMapList->at(l1); if (mm->isMap(evIn)) { unmatched = false; mm->doMap(evIn, &evOut, &outOfRange); if (!outOfRange) { snd_seq_ev_set_subs(&evOut); snd_seq_ev_set_direct(&evOut); snd_seq_ev_set_source(&evOut, portid_out[mm->portOut]); snd_seq_event_output_direct(seq_handle, &evOut); } } } if (!discardUnmatched && unmatched) { snd_seq_ev_set_subs(evIn); snd_seq_ev_set_direct(evIn); snd_seq_ev_set_source(evIn, portid_out[portUnmatched]); snd_seq_event_output_direct(seq_handle, evIn); } } while (snd_seq_event_input_pending(seq_handle, 0) > 0); }
void midibus::continue_from( long a_tick ) { /* tell the device that we are going to start at a certain position */ long pp16th = (c_ppqn / 4); long leftover = ( a_tick % pp16th ); long beats = ( a_tick / pp16th ); long starting_tick = a_tick - leftover; /* was there anything left?, then wait for next beat (16th note) to start clocking */ if ( leftover > 0) { starting_tick += pp16th; } //printf ( "continue_from leftover[%ld] starting_tick[%ld]\n", leftover, starting_tick ); m_lasttick = starting_tick - 1; if ( m_clock_type != e_clock_off ) { //printf( "control value %ld\n", beats); snd_seq_event_t evc; snd_seq_event_t ev; ev.type = SND_SEQ_EVENT_CONTINUE; evc.type = SND_SEQ_EVENT_SONGPOS; evc.data.control.value = beats; snd_seq_ev_set_fixed( &ev ); snd_seq_ev_set_fixed( &evc ); snd_seq_ev_set_priority( &ev, 1 ); snd_seq_ev_set_priority( &evc, 1 ); /* set source */ snd_seq_ev_set_source(&evc, m_local_addr_port ); snd_seq_ev_set_subs(&evc); snd_seq_ev_set_source(&ev, m_local_addr_port ); snd_seq_ev_set_subs(&ev); // its immediate snd_seq_ev_set_direct( &ev ); snd_seq_ev_set_direct( &evc ); /* pump it into the queue */ snd_seq_event_output(m_seq, &evc); flush(); snd_seq_event_output(m_seq, &ev); } }
void midibus::clock (midipulse tick) { #ifdef SEQ64_HAVE_LIBASOUND automutex locker(m_mutex); if (m_clock_type != e_clock_off) { bool done = m_lasttick >= tick; int ct = clock_ticks_from_ppqn(m_ppqn); /* ppqn / 24 */ while (! done) { ++m_lasttick; done = m_lasttick >= tick; if ((m_lasttick % ct) == 0) /* tick time? */ { /* * Set the event tag to 127 so the sequences won't remove it. */ snd_seq_event_t ev; ev.type = SND_SEQ_EVENT_CLOCK; ev.tag = 127; snd_seq_ev_set_fixed(&ev); snd_seq_ev_set_priority(&ev, 1); snd_seq_ev_set_source(&ev, m_local_addr_port); /* set source */ snd_seq_ev_set_subs(&ev); snd_seq_ev_set_direct(&ev); /* it's immediate */ snd_seq_event_output(m_seq, &ev); /* pump it into queue */ } } flush(); /* and send out */ } #endif // SEQ64_HAVE_LIBASOUND }
static void note_on(int note, real_t power) { snd_seq_event_t ev; if (debug>1) fprintf(stderr, "midimatch: (%ld) note on: note:%-3d p:%.2f name:%s@%d\n", absolute_time, note, power, midi_notename(note), midi_octave(note)); else if (debug>0) fprintf(stderr, "."); stats_note_ons ++; act_freq[note] = 1; if (midi_file != NULL ) { midi_write_note_event(0x90 | midi_channel, note, 100, midi_file); } if ( use_sequencer ) { snd_seq_ev_clear(&ev); snd_seq_ev_set_source(&ev, 0); snd_seq_ev_set_subs(&ev); snd_seq_ev_set_direct(&ev); snd_seq_ev_set_noteon(&ev, midi_channel, note, 100) ; snd_seq_event_output(midi_sequencer, &ev); snd_seq_drain_output(midi_sequencer); } }
static void note_off(int note, real_t power) { snd_seq_event_t ev; if (debug>2) fprintf(stderr, "midimatch: (%ld) note off: note:%-3d p:%.2f maxp:%0.2f\n", absolute_time, note, power, act_freq[note]); act_freq[note] = 0.0f; if (midi_file != NULL ) midi_write_note_event(0x80 | midi_channel, note, 100, midi_file); if ( use_sequencer ) { snd_seq_ev_clear(&ev); snd_seq_ev_set_source(&ev, 0); snd_seq_ev_set_subs(&ev); snd_seq_ev_set_direct(&ev); snd_seq_ev_set_noteoff(&ev, midi_channel, note, 100) ; snd_seq_event_output(midi_sequencer, &ev); snd_seq_drain_output(midi_sequencer); } }
void sendMessageNow (const MidiMessage& message) { if (message.getRawDataSize() > maxEventSize) { maxEventSize = message.getRawDataSize(); snd_midi_event_free (midiParser); snd_midi_event_new (maxEventSize, &midiParser); } snd_seq_event_t event; snd_seq_ev_clear (&event); long numBytes = (long) message.getRawDataSize(); const uint8* data = message.getRawData(); while (numBytes > 0) { const long numSent = snd_midi_event_encode (midiParser, data, numBytes, &event); if (numSent <= 0) break; numBytes -= numSent; data += numSent; snd_seq_ev_set_source (&event, 0); snd_seq_ev_set_subs (&event); snd_seq_ev_set_direct (&event); snd_seq_event_output (seqHandle, &event); } snd_seq_drain_output (seqHandle); snd_midi_event_reset_encode (midiParser); }
void qxgeditMidiDevice::sendSysex ( unsigned char *pSysex, unsigned short iSysex ) const { #ifdef CONFIG_DEBUG fprintf(stderr, "qxgeditMidiDevice::sendSysex(%p, %u)", pSysex, iSysex); fprintf(stderr, " sysex {"); for (unsigned short i = 0; i < iSysex; ++i) fprintf(stderr, " %02x", pSysex[i]); fprintf(stderr, " }\n"); #endif // Don't do anything else if engine // has not been activated... if (m_pAlsaSeq == NULL) return; // Initialize sequencer event... snd_seq_event_t ev; snd_seq_ev_clear(&ev); // Addressing... snd_seq_ev_set_source(&ev, m_iAlsaPort); snd_seq_ev_set_subs(&ev); // The event will be direct... snd_seq_ev_set_direct(&ev); // Just set SYSEX stuff and send it out.. ev.type = SND_SEQ_EVENT_SYSEX; snd_seq_ev_set_sysex(&ev, iSysex, pSysex); snd_seq_event_output_direct(m_pAlsaSeq, &ev); }
void midibus::play (event * a_e24, unsigned char a_channel) { #ifdef HAVE_LIBASOUND automutex locker(m_mutex); snd_seq_event_t ev; snd_midi_event_t *midi_ev; /* ALSA MIDI parser */ unsigned char buffer[3]; /* temp for MIDI data */ /* fill buffer and set midi channel */ buffer[0] = a_e24->get_status(); buffer[0] += (a_channel & 0x0F); a_e24->get_data(&buffer[1], &buffer[2]); snd_midi_event_new(10, &midi_ev); /* clear event */ snd_seq_ev_clear(&ev); snd_midi_event_encode(midi_ev, buffer, 3, &ev); snd_midi_event_free(midi_ev); /* set source */ snd_seq_ev_set_source(&ev, m_local_addr_port); snd_seq_ev_set_subs(&ev); snd_seq_ev_set_direct(&ev); // its immediate /* pump it into the queue */ snd_seq_event_output(m_seq, &ev); #endif // HAVE_LIBASOUND }
void aubio_midi_direct_output(aubio_midi_driver_t * d, aubio_midi_event_t * event) { aubio_alsa_seq_driver_t* dev = (aubio_alsa_seq_driver_t*) d; switch(event->type) { case NOTE_ON: ev.type = SND_SEQ_EVENT_NOTEON; ev.data.note.channel = event->channel; ev.data.note.note = event->param1; ev.data.note.velocity = event->param2; //AUBIO_ERR( "NOTE_ON %d\n", event->param1); break; case NOTE_OFF: ev.type = SND_SEQ_EVENT_NOTEOFF; ev.data.note.channel = event->channel; ev.data.note.note = event->param1; ev.data.note.velocity = event->param2; //AUBIO_ERR( "NOTE_OFF %d\n", event->param1); break; default: break; } if (ev.type == SND_SEQ_EVENT_NOTEOFF || ev.type == SND_SEQ_EVENT_NOTEON ) { snd_seq_ev_set_subs(&ev); snd_seq_ev_set_direct(&ev); snd_seq_ev_set_source(&ev, dev->seq_port); snd_seq_event_output_direct(dev->seq_handle, &ev); } }
void midibus::stop() { m_lasttick = -1; if ( m_clock_type != e_clock_off ){ snd_seq_event_t ev; ev.type = SND_SEQ_EVENT_STOP; snd_seq_ev_set_fixed( &ev ); snd_seq_ev_set_priority( &ev, 1 ); /* set source */ snd_seq_ev_set_source(&ev, m_local_addr_port ); snd_seq_ev_set_subs(&ev); // its immediate snd_seq_ev_set_direct( &ev ); /* pump it into the queue */ snd_seq_event_output(m_seq, &ev); } }
void sendMessageNow (const MidiMessage& message) { if (message.getRawDataSize() > maxEventSize) { maxEventSize = message.getRawDataSize(); snd_midi_event_free (midiParser); snd_midi_event_new (maxEventSize, &midiParser); } snd_seq_event_t event; snd_seq_ev_clear (&event); snd_midi_event_encode (midiParser, message.getRawData(), message.getRawDataSize(), &event); snd_midi_event_reset_encode (midiParser); snd_seq_ev_set_source (&event, 0); snd_seq_ev_set_subs (&event); snd_seq_ev_set_direct (&event); snd_seq_event_output (seqHandle, &event); snd_seq_drain_output (seqHandle); }
void* lp2midi(void* nothing) { printf("waiting for launchpad events\n"); snd_seq_event_t event; while (1) { // wait for an event lp_receive(lp); // setup snd_seq_ev_clear(&event); snd_seq_ev_set_source(&event, midi_out); // set the output port number snd_seq_ev_set_subs(&event); // broadcast to subscribers // fill the event switch(lp->event[0]) { case NOTE: snd_seq_ev_set_noteon(&event, 0, lp->event[1], lp->event[2]); break; case CTRL: snd_seq_ev_set_controller(&event, 0, lp->event[1], lp->event[2]); break; } // send now snd_seq_ev_set_direct(&event); snd_seq_event_output(midi_client, &event); snd_seq_drain_output(midi_client); } }
void stop_midireceiver (JackVST *jvst) { int err; snd_seq_event_t event; snd_seq_t *seq2 = create_sequencer ("jfstquit", true); jvst->midiquit = 1; snd_seq_connect_to (seq2, 0, snd_seq_client_id (jvst->seq),0); snd_seq_ev_clear (&event); snd_seq_ev_set_direct (&event); snd_seq_ev_set_subs (&event); snd_seq_ev_set_source (&event, 0); snd_seq_ev_set_controller (&event,1,0x80,50); if ((err = snd_seq_event_output (seq2, &event)) < 0) { fst_error ("cannot send stop event to midi thread: %s\n", snd_strerror (err)); } snd_seq_drain_output (seq2); snd_seq_close (seq2); pthread_join (jvst->midi_thread,NULL); snd_seq_close (jvst->seq); }
void send_event() { snd_seq_ev_set_direct(&ev); snd_seq_ev_set_source(&ev, my_port); snd_seq_ev_set_dest(&ev, seq_client, seq_port); snd_seq_event_output(seq_handle, &ev); snd_seq_drain_output(seq_handle); }
void midi_noteon_alsa(struct midi_handle *mh, unsigned char port, unsigned char channel, unsigned char value, unsigned char volume) { struct midi_handle_alsa *mha = (struct midi_handle_alsa *) mh; snd_seq_event_t ev; struct snd_seq_real_time tstamp; int rc; if (port >= MAX_PORTS) return; memset(&tstamp, 0, sizeof(tstamp)); snd_seq_ev_clear(&ev); snd_seq_ev_set_source(&ev, mha->outputport[port]); snd_seq_ev_set_subs(&ev); /* snd_seq_ev_set_dest(&ev, 128, 0); */ snd_seq_ev_set_subs(&ev); snd_seq_ev_set_noteon(&ev, channel, value, volume); /* ev.data.note.duration = 1000; */ /* it's drums... there is no note off. */ snd_seq_ev_schedule_real(&ev, mha->queue, 1, &tstamp); /* printf("Sending event to port %d, chan=%d, note=%d, vel=%d, pid=%d\n", mha->outputport, ev.data.note.channel, ev.data.note.note, ev.data.note.velocity, getpid()); */ rc = snd_seq_event_output(mha->seqp, &ev); if (rc < 0) printf("Failed to output note.\n"); snd_seq_drain_output(mha->seqp); return; }
void midibus::continue_from (midipulse tick) { #ifdef SEQ64_HAVE_LIBASOUND /* * Tell the device that we are going to start at a certain position. */ midipulse pp16th = m_ppqn / 4; midipulse leftover = tick % pp16th; long beats = tick / pp16th; midipulse starting_tick = tick - leftover; /* * Was there anything left? Then wait for next beat (16th note) to * start clocking. */ if (leftover > 0) starting_tick += pp16th; m_lasttick = starting_tick - 1; if (m_clock_type != e_clock_off) { snd_seq_event_t ev; ev.type = SND_SEQ_EVENT_CONTINUE; snd_seq_event_t evc; evc.type = SND_SEQ_EVENT_SONGPOS; evc.data.control.value = beats; snd_seq_ev_set_fixed(&ev); snd_seq_ev_set_fixed(&evc); snd_seq_ev_set_priority(&ev, 1); snd_seq_ev_set_priority(&evc, 1); snd_seq_ev_set_source(&evc, m_local_addr_port); /* set the source */ snd_seq_ev_set_subs(&evc); snd_seq_ev_set_source(&ev, m_local_addr_port); snd_seq_ev_set_subs(&ev); snd_seq_ev_set_direct(&ev); /* it's immediate */ snd_seq_ev_set_direct(&evc); snd_seq_event_output(m_seq, &evc); /* pump into queue */ flush(); snd_seq_event_output(m_seq, &ev); } #endif // SEQ64_HAVE_LIBASOUND }
static PyObject * alsaseq_output(PyObject *self, PyObject *args) { snd_seq_event_t ev; static PyObject * data; if (!PyArg_ParseTuple(args, "(bbbb(ii)(bb)(bb)O)", &ev.type, &ev.flags, &ev.tag, &ev.queue, &ev.time.time.tv_sec, &ev.time.time.tv_nsec, &ev.source.client, &ev.source.port, &ev.dest.client, &ev.dest.port, &data )) return NULL; if (!seq_handle) { PyErr_SetString(PyExc_RuntimeError, "Must initialize module with alsaseq.client() before using it"); return NULL; } /* printf ( "event.type: %d\n", ev.type ); */ switch( ev.type ) { case SND_SEQ_EVENT_NOTE: case SND_SEQ_EVENT_NOTEON: case SND_SEQ_EVENT_NOTEOFF: case SND_SEQ_EVENT_KEYPRESS: if (!PyArg_ParseTuple( data, "bbbbi;data parameter should have 5 values", &ev.data.note.channel, &ev.data.note.note, &ev.data.note.velocity, &ev.data.note.off_velocity, &ev.data.note.duration)) return NULL; break; case SND_SEQ_EVENT_CONTROLLER: case SND_SEQ_EVENT_PGMCHANGE: case SND_SEQ_EVENT_CHANPRESS: case SND_SEQ_EVENT_PITCHBEND: if (!PyArg_ParseTuple( data, "bbbbii;data parameter should have 6 values", &ev.data.control.channel, &ev.data.control.unused[0], &ev.data.control.unused[1], &ev.data.control.unused[2], &ev.data.control.param, &ev.data.control.value )) return NULL; break; } /* If not a direct event, use the queue */ if ( ev.queue != SND_SEQ_QUEUE_DIRECT ) ev.queue = queue_id; /* Modify source port if out of bounds */ if ( ev.source.port < firstoutputport ) snd_seq_ev_set_source(&ev, firstoutputport ); else if ( ev.source.port > lastoutputport ) snd_seq_ev_set_source(&ev, lastoutputport ); /* Use subscribed ports, except if ECHO event */ if ( ev.type != SND_SEQ_EVENT_ECHO ) snd_seq_ev_set_subs(&ev); snd_seq_event_output_direct( seq_handle, &ev ); Py_INCREF(Py_None); return Py_None; }
void MidiDriver_ALSA::send_event(int do_flush) { snd_seq_ev_set_direct(&ev); snd_seq_ev_set_source(&ev, my_port); snd_seq_ev_set_dest(&ev, seq_client, seq_port); snd_seq_event_output(seq_handle, &ev); if (do_flush) snd_seq_flush_output(seq_handle); }
static void send() { snd_seq_ev_set_source(&ev, readable_port); snd_seq_ev_set_dest(&ev, dest_client_id, 0); snd_seq_ev_set_direct(&ev); snd_seq_event_output(seq, &ev); snd_seq_drain_output(seq); }
static void do_jack_output(alsa_seqmidi_t *self, port_t *port, struct process_info* info) { stream_t *str = &self->stream[info->dir]; int nevents = jack_midi_get_event_count(port->jack_buf); int i; for (i=0; i<nevents; ++i) { jack_midi_event_t jack_event; snd_seq_event_t alsa_event; int64_t frame_offset; int64_t out_time; snd_seq_real_time_t out_rt; int err; jack_midi_event_get(&jack_event, port->jack_buf, i); snd_seq_ev_clear(&alsa_event); snd_midi_event_reset_encode(str->codec); if (!snd_midi_event_encode(str->codec, jack_event.buffer, jack_event.size, &alsa_event)) continue; // invalid event snd_seq_ev_set_source(&alsa_event, self->port_id); snd_seq_ev_set_dest(&alsa_event, port->remote.client, port->remote.port); /* NOTE: in case of xrun it could become negative, so it is essential to use signed type! */ frame_offset = (int64_t)jack_event.time + info->period_start + info->nframes - info->cur_frames; if (frame_offset < 0) { frame_offset = info->nframes + jack_event.time; error_log("internal xrun detected: frame_offset = %"PRId64"\n", frame_offset); } /* Ken Ellinwood reported problems with this assert. * Seems, magic 2 should be replaced with nperiods. */ //FIXME: assert (frame_offset < info->nframes*2); //if (frame_offset < info->nframes * info->nperiods) // debug_log("alsa_out: BLAH-BLAH-BLAH"); out_time = info->alsa_time + (frame_offset * NSEC_PER_SEC) / info->sample_rate; debug_log("alsa_out: frame_offset = %lld, info->alsa_time = %lld, out_time = %lld, port->last_out_time = %lld", frame_offset, info->alsa_time, out_time, port->last_out_time); // we should use absolute time to prevent reordering caused by rounding errors if (out_time < port->last_out_time) { debug_log("alsa_out: limiting out_time %lld at %lld", out_time, port->last_out_time); out_time = port->last_out_time; } else port->last_out_time = out_time; out_rt.tv_nsec = out_time % NSEC_PER_SEC; out_rt.tv_sec = out_time / NSEC_PER_SEC; snd_seq_ev_schedule_real(&alsa_event, self->queue, 0, &out_rt); err = snd_seq_event_output(self->seq, &alsa_event); debug_log("alsa_out: written %d bytes to %s at %+d (%lld): %d", (int)jack_event.size, port->name, (int)frame_offset, out_time, err); } }
// generates midi clock void midibus::clock( long a_tick ) { lock(); if ( m_clock_type != e_clock_off ){ bool done = false; long uptotick = a_tick; if ( m_lasttick >= uptotick ) done = true; while ( !done ){ m_lasttick++; if ( m_lasttick >= uptotick ) done = true; /* tick time? */ if ( m_lasttick % ( c_ppqn / 24 ) == 0 ){ snd_seq_event_t ev; ev.type = SND_SEQ_EVENT_CLOCK; /* set tag to 127 so the sequences wont remove it */ ev.tag = 127; snd_seq_ev_set_fixed( &ev ); snd_seq_ev_set_priority( &ev, 1 ); /* set source */ snd_seq_ev_set_source(&ev, m_local_addr_port ); snd_seq_ev_set_subs(&ev); // its immediate snd_seq_ev_set_direct( &ev ); /* pump it into the queue */ snd_seq_event_output(m_seq, &ev); } } /* and send out */ flush(); } unlock(); }
void synth_noteStop(synth_t * st,int num, int status) { snd_seq_event_t ev; snd_seq_ev_clear(&ev); snd_seq_ev_set_direct(&ev); snd_seq_ev_set_source(&ev, port_out_id); snd_seq_ev_set_subs(&ev); //usleep(100000); printf("synth_noteStop %d\n", st->runningNote[num]); snd_seq_ev_set_noteoff(&ev, st->channel, st->runningNote[num], st->velocity); snd_seq_event_output_direct(seq, &ev); snd_seq_drain_output(seq); }
void MidiQueue::enqueueMidiMessage(const snd_seq_event_type messageType, const int sourcePort, const snd_seq_tick_time_t& tick) { snd_seq_event_t event = {}; event.type = messageType; snd_seq_ev_schedule_tick(&event, _id, 1, tick); snd_seq_ev_set_source(&event, sourcePort); snd_seq_ev_set_subs(&event); int result = snd_seq_event_output_direct(_sequencer, &event); if (result < 0) { std::cerr << "MidiQueue::enqueueMidiMessage error:" << snd_strerror(result) << std::endl; } }
void rimshot_alsa_output_play_note (rimshot_alsa_output_t *output, int channel, int note, unsigned int velocity) { snd_seq_event_t ev; snd_seq_ev_clear (&ev); snd_seq_ev_set_source (&ev, output->port); snd_seq_ev_set_subs (&ev); snd_seq_ev_set_direct (&ev); snd_seq_ev_set_noteon (&ev, channel, note, velocity); snd_seq_event_output_direct (output->seq, &ev); }
void synth_noteStart(synth_t * st,int num, int status) { snd_seq_event_t ev; snd_seq_ev_clear(&ev); snd_seq_ev_set_direct(&ev); snd_seq_ev_set_source(&ev, port_out_id); snd_seq_ev_set_subs(&ev); printf("synth_noteStart %d\n", st->btn2note[num]); int note = st->btn2note[num]+st->sharp+12*st->octaveUp-12*st->octaveDown; st->runningNote[num]=note; snd_seq_ev_set_noteon(&ev, st->channel, note, st->velocity); snd_seq_event_output_direct(seq, &ev); snd_seq_drain_output(seq); }
static gboolean put_click (const DrumClick *click) { snd_seq_event_t ev; snd_seq_ev_clear (&ev); snd_seq_ev_set_source (&ev, out_port_id); snd_seq_ev_set_subs (&ev); snd_seq_ev_schedule_tick (&ev, queue_id, 0, click->tick); snd_seq_ev_set_note (&ev, 10, 24, click->velocity, 48); int err = snd_seq_event_output_direct (seq, &ev); return err >= 0; }
void pitch_alsa(void* seqq, unsigned char chan, short val) { ALSA_SEQ* seq = (ALSA_SEQ*)seqq; snd_seq_event_t ev; snd_seq_ev_clear(&ev); snd_seq_ev_set_source(&ev, seq->g_port); snd_seq_ev_set_subs(&ev); snd_seq_ev_set_direct(&ev); snd_seq_ev_set_pitchbend(&ev, chan, val); snd_seq_event_output(seq->g_seq, &ev); snd_seq_drain_output(seq->g_seq); }
/* takes an native event, encodes to alsa event, puts it in the queue */ void midibus::play( event *a_e24, unsigned char a_channel ) { lock(); snd_seq_event_t ev; /* alsa midi parser */ snd_midi_event_t *midi_ev; /* temp for midi data */ unsigned char buffer[3]; /* fill buffer and set midi channel */ buffer[0] = a_e24->get_status(); buffer[0] += (a_channel & 0x0F); a_e24->get_data( &buffer[1], &buffer[2] ); snd_midi_event_new( 10, &midi_ev ); /* clear event */ snd_seq_ev_clear( &ev ); snd_midi_event_encode( midi_ev, buffer, 3, &ev ); snd_midi_event_free( midi_ev ); /* set source */ snd_seq_ev_set_source(&ev, m_local_addr_port ); snd_seq_ev_set_subs(&ev); /* set tag unique to each sequence for removal purposes */ //ev.tag = a_tag; // its immediate snd_seq_ev_set_direct( &ev ); /* pump it into the queue */ snd_seq_event_output(m_seq, &ev); unlock(); }
void midi_send(uint32 data) { snd_seq_event_t ev; if (s_midi == NULL) return; snd_seq_ev_clear(&ev); snd_seq_ev_set_source(&ev, s_midiPort); snd_seq_ev_set_subs(&ev); snd_seq_ev_set_direct(&ev); snd_midi_event_encode(s_midiCoder, (uint8 *)&data, sizeof(uint32), &ev); snd_seq_event_output(s_midi, &ev); snd_seq_drain_output(s_midi); }
void prog_alsa(void* seqq, unsigned char chan, unsigned char indx) { ALSA_SEQ* seq = (ALSA_SEQ*)seqq; snd_seq_event_t ev; snd_seq_ev_clear(&ev); snd_seq_ev_set_source(&ev, seq->g_port); snd_seq_ev_set_subs(&ev); snd_seq_ev_set_direct(&ev); //... // set event type, data, so on.. snd_seq_ev_set_pgmchange(&ev, chan, indx); snd_seq_event_output(seq->g_seq, &ev); snd_seq_drain_output(seq->g_seq); }