void JVlibForm::on_System_MIDI_progressBar_sliderReleased() { if (!System_PauseMidi_button->isChecked()) return; snd_seq_event_t ev; snd_seq_ev_clear(&ev); snd_seq_ev_set_direct(&ev); snd_seq_get_queue_status(seq, queue, status); // reset queue position snd_seq_ev_is_tick(&ev); snd_seq_ev_set_queue_pos_tick(&ev, queue, 0); snd_seq_event_output(seq, &ev); snd_seq_drain_output(seq); // scan the event queue for the closest tick >= 'x' int y = 0; for (std::vector<event>::iterator Event=all_events.begin(); Event!=all_events.end(); ++Event) { if (static_cast<int>(Event->tick) >= System_MIDI_progressBar->sliderPosition()) { ev.time.tick = Event->tick; event_num = y; break; } y++; } ev.dest.client = SND_SEQ_CLIENT_SYSTEM; ev.dest.port = SND_SEQ_PORT_SYSTEM_TIMER; snd_seq_ev_set_queue_pos_tick(&ev, queue, ev.time.tick); snd_seq_event_output(seq, &ev); snd_seq_drain_output(seq); snd_seq_real_time_t *new_time = new snd_seq_real_time_t; double x = static_cast<double>(ev.time.tick)/all_events.back().tick; new_time->tv_sec = (x*song_length_seconds); new_time->tv_nsec = 0; snd_seq_ev_set_queue_pos_real(&ev, queue, new_time); MIDI_time_display->setText(QString::number(static_cast<int>(new_time->tv_sec)/60).rightJustified(2,'0')+ ":"+QString::number(static_cast<int>(new_time->tv_sec)%60).rightJustified(2,'0')); if (System_PauseMidi_button->isChecked()) return; } // end on_System_MIDI_progressBar_sliderReleased
void MIDIDevice::feedBack(t_input_channel channel, t_input_value value) { /* MIDI devices can have only 128 notes or controllers */ if (channel < 128) { snd_seq_event_t ev; MIDIInput* plugin; plugin = static_cast<MIDIInput*> (parent()); Q_ASSERT(plugin != NULL); Q_ASSERT(plugin->alsa() != NULL); Q_ASSERT(m_address != NULL); /* Setup an event structure */ snd_seq_ev_clear(&ev); snd_seq_ev_set_dest(&ev, m_address->client, m_address->port); snd_seq_ev_set_subs(&ev); snd_seq_ev_set_direct(&ev); /* Send control change, channel 1 (0) */ snd_seq_ev_set_controller(&ev, 0, channel, value >> 1); snd_seq_event_output(plugin->alsa(), &ev); snd_seq_drain_output(plugin->alsa()); /* Send note on/off, channel 1 (0) */ if (value == 0) snd_seq_ev_set_noteoff(&ev, 0, channel, 0); else snd_seq_ev_set_noteon(&ev, 0, channel, value >> 1); snd_seq_event_output(plugin->alsa(), &ev); snd_seq_drain_output(plugin->alsa()); }
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 MIDIDevice::feedBack(t_input_channel channel, t_input_value value) { /* MIDI devices can have only 128 notes or controllers */ if (channel < 128) { snd_seq_event_t ev; MIDIInput* plugin; plugin = static_cast<MIDIInput*> (parent()); Q_ASSERT(plugin != NULL); Q_ASSERT(plugin->alsa() != NULL); Q_ASSERT(m_address != NULL); /* Setup an event structure */ snd_seq_ev_clear(&ev); snd_seq_ev_set_dest(&ev, m_address->client, m_address->port); snd_seq_ev_set_subs(&ev); snd_seq_ev_set_direct(&ev); char scaled = static_cast <char> (SCALE(double(value), double(0), double(KInputValueMax), double(0), double(127))); if (m_mode == ControlChange) { /* Send control change */ snd_seq_ev_set_controller(&ev, midiChannel(), channel, scaled); snd_seq_event_output(plugin->alsa(), &ev); snd_seq_drain_output(plugin->alsa()); } else { /* Send note on/off */ if (value == 0) { snd_seq_ev_set_noteoff(&ev, midiChannel(), channel, scaled); } else { snd_seq_ev_set_noteon(&ev, midiChannel(), channel, scaled); } snd_seq_event_output(plugin->alsa(), &ev); snd_seq_drain_output(plugin->alsa()); } } }
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 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); } }
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); } }
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); }
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 MIDIDevice::outputDMX(const QByteArray& universe) { MIDIOut* plugin = static_cast<MIDIOut*> (parent()); Q_ASSERT(plugin != NULL); Q_ASSERT(plugin->alsa() != NULL); Q_ASSERT(m_address != NULL); /* Setup a common event structure for all values */ snd_seq_event_t ev; snd_seq_ev_clear(&ev); snd_seq_ev_set_dest(&ev, m_address->client, m_address->port); snd_seq_ev_set_subs(&ev); snd_seq_ev_set_direct(&ev); /* Since MIDI devices can have only 128 real channels, we don't attempt to write more than that */ for (unsigned char channel = 0; channel < MAX_MIDI_DMX_CHANNELS; channel++) { /* Scale 0-255 to 0-127 */ char scaled = DMX2MIDI(universe[channel]); /* Since MIDI is so slow, we only send values that are actually changed. */ if (m_values[channel] == scaled) continue; /* Store the changed MIDI value */ m_values[channel] = scaled; if (mode() == Note) { if (scaled == 0) { /* 0 is sent as a note off command */ snd_seq_ev_set_noteoff(&ev, midiChannel(), channel, scaled); } else { /* 1-127 is sent as note on command */ snd_seq_ev_set_noteon(&ev, midiChannel(), channel, scaled); } snd_seq_event_output(plugin->alsa(), &ev); } else { /* Control change */ snd_seq_ev_set_controller(&ev, midiChannel(), channel, scaled); snd_seq_event_output_buffer(plugin->alsa(), &ev); } } /* Make sure that all values go to the MIDI endpoint */ snd_seq_drain_output(plugin->alsa()); }
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 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 }
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::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); 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 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 }
void MIDIDevice::feedBack(quint32 channel, uchar value) { MIDIInput* plugin = static_cast<MIDIInput*> (parent()); Q_ASSERT(plugin != NULL); Q_ASSERT(plugin->alsa() != NULL); Q_ASSERT(m_address != NULL); uchar cmd = 0; uchar data1 = 0; uchar data2 = 0; bool d2v = false; if (QLCMIDIProtocol::feedbackToMidi(channel, value, midiChannel(), &cmd, &data1, &data2, &d2v) == true) { /* Setup an event structure */ snd_seq_event_t ev; snd_seq_ev_clear(&ev); snd_seq_ev_set_dest(&ev, m_address->client, m_address->port); snd_seq_ev_set_subs(&ev); snd_seq_ev_set_direct(&ev); if (MIDI_CMD(cmd) == MIDI_NOTE_OFF) { /* Send data as note off command */ snd_seq_ev_set_noteoff(&ev, midiChannel(), data1, data2); snd_seq_event_output(plugin->alsa(), &ev); snd_seq_drain_output(plugin->alsa()); } else if (MIDI_CMD(cmd) == MIDI_NOTE_ON) { /* Send data as note on command */ snd_seq_ev_set_noteon(&ev, midiChannel(), data1, data2); snd_seq_event_output(plugin->alsa(), &ev); snd_seq_drain_output(plugin->alsa()); } else if (MIDI_CMD(cmd) == MIDI_CONTROL_CHANGE) { /* Send data as control change command */ snd_seq_ev_set_controller(&ev, midiChannel(), data1, data2); snd_seq_event_output(plugin->alsa(), &ev); snd_seq_drain_output(plugin->alsa()); } } }
void performNoteEventStep(noteEventStep_t *noteEventStep) { if ((pendingOff != NULL)&&(pendingOff->off.noteOffLink != NULL)) { noteValue_t *noteValue = (noteValue_t *) pendingOff->noteValue; snd_seq_event_t *snd_seq_event = (snd_seq_event_t *) noteValue->snd_seq_event; snd_seq_event->dest = sequencer.snd_seq_addr; snd_seq_event->type = SND_SEQ_EVENT_NOTEOFF; snd_seq_event_output(sequencer.snd_seq, snd_seq_event); notesOff.value = g_slist_delete_link((GSList *) notesOff.value, (GSList *) pendingOff->off.noteOffLink); pendingOff->off.noteOffLink = NULL; pendingOff = NULL; } if ((noteEventStep->offNoteEvent != NULL)&& (noteEventStep->offNoteEvent->off.noteOffLink != NULL)) { if (noteEventStep->onNoteEvent == NULL) { noteEventStep->offNoteEvent->noteValue->snd_seq_event->dest = sequencer.snd_seq_addr; noteEventStep->offNoteEvent->noteValue->snd_seq_event->type = SND_SEQ_EVENT_NOTEOFF; snd_seq_event_output(sequencer.snd_seq, (snd_seq_event_t *) noteEventStep->offNoteEvent->noteValue->snd_seq_event); notesOff.value = g_slist_delete_link((GSList *) notesOff.value, (GSList *) noteEventStep->offNoteEvent->off.noteOffLink); noteEventStep->offNoteEvent->off.noteOffLink = NULL; } else { pendingOff = (struct noteEvent *) noteEventStep->offNoteEvent; } } if (noteEventStep->onNoteEvent != NULL) { noteEventStep->onNoteEvent->noteValue->snd_seq_event->dest = sequencer.snd_seq_addr; noteEventStep->onNoteEvent->noteValue->snd_seq_event->type = SND_SEQ_EVENT_NOTEON; snd_seq_event_output(sequencer.snd_seq, (snd_seq_event_t *) noteEventStep->onNoteEvent->noteValue->snd_seq_event); notesOff.value = noteEventStep->onNoteEvent->on.offNoteEvent->off.noteOffLink = g_slist_prepend(((GSList *) notesOff.value), (GSList *) noteEventStep->onNoteEvent->on.offNoteEvent); } }
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); }
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 ssize_t snd_rawmidi_virtual_write(snd_rawmidi_t *rmidi, const void *buffer, size_t size) { snd_rawmidi_virtual_t *virt = rmidi->private_data; ssize_t result = 0; ssize_t size1; int err; if (virt->pending) { err = snd_seq_event_output(virt->handle, &virt->out_event); if (err < 0) { if (err != -EAGAIN) /* we got some fatal error. removing this event * at the next time */ virt->pending = 0; return err; } virt->pending = 0; } while (size > 0) { size1 = snd_midi_event_encode(virt->midi_event, buffer, size, &virt->out_event); if (size1 <= 0) break; size -= size1; result += size1; buffer += size1; if (virt->out_event.type == SND_SEQ_EVENT_NONE) continue; snd_seq_ev_set_subs(&virt->out_event); snd_seq_ev_set_source(&virt->out_event, virt->port); snd_seq_ev_set_direct(&virt->out_event); err = snd_seq_event_output(virt->handle, &virt->out_event); if (err < 0) { virt->pending = 1; return result > 0 ? result : err; } } if (result > 0) snd_seq_drain_output(virt->handle); return result; }
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(); }
/** * \brief queue controls - start/stop/continue * \param seq sequencer handle * \param q queue id to control * \param type event type * \param value event value * \param ev event instance * * This function sets up general queue control event and sends it. * To send at scheduled time, set the schedule in \a ev. * If \a ev is NULL, the event is composed locally and sent immediately * to the specified queue. In any cases, you need to call #snd_seq_drain_output() * appropriately to feed the event. * * \sa snd_seq_alloc_queue() */ int snd_seq_control_queue(snd_seq_t *seq, int q, int type, int value, snd_seq_event_t *ev) { snd_seq_event_t tmpev; if (ev == NULL) { snd_seq_ev_clear(&tmpev); ev = &tmpev; snd_seq_ev_set_direct(ev); } snd_seq_ev_set_queue_control(ev, type, q, value); return snd_seq_event_output(seq, ev); }
/* * Write out the event. This routine blocks until * successfully written. * * Arguments: * ctxp - Application context * ep - Event */ int SeqContext::seq_write(snd_seq_event_t *ep) { int err = 0; err = snd_seq_event_output(handle, ep); if( err < 0 ) fprintf(stderr, "Error: SeqEvent output failure, err=%d\n", err); else if( verbose ) fprintf(stderr, " SeqEvent outputted, cnt=%d\n", err); return err; }
// change the tempo on the fly int change_tempo(snd_seq_t *handle, int my_client_id, int my_port_id, int q, unsigned int tempo) { snd_seq_event_t ev; snd_seq_ev_clear(&ev); ev.dest.client = SND_SEQ_CLIENT_SYSTEM; ev.dest.port = SND_SEQ_PORT_SYSTEM_TIMER; ev.source.client = my_client_id; ev.source.port = my_port_id; ev.queue = SND_SEQ_QUEUE_DIRECT; // no scheduling ev.data.queue.queue = q; // affected queue id ev.data.queue.param.value = tempo; // new tempo in microsec. return snd_seq_event_output(handle, &ev); }
void performControllerEventStep(controllerEventStep_t *controllerEventStep) { if (controllerEventStep->controllerValue == NULL) { goto finish; } controllerEventStep->controllerValue->snd_seq_event->dest = sequencer.snd_seq_addr; snd_seq_event_output(sequencer.snd_seq, (snd_seq_event_t *) controllerEventStep->controllerValue->snd_seq_event); finish: return; }
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(); }