自学教程：C++ snd_seq_drain_output函数代码示例

void JVlibForm::on_System_PauseMidi_button_toggled(bool checked){  unsigned int current_tick;  if (checked) {      stopPlayer();      if (seqTimer->isActive()) {            disconnect(JVlibForm::seqTimer, SIGNAL(timeout()), this, SLOT(tickDisplay()));            seqTimer->stop();      }        snd_seq_get_queue_status(seq, queue, status);	current_tick = snd_seq_queue_status_get_tick_time(status);        snd_seq_stop_queue(seq,queue,NULL);        snd_seq_drain_output(seq);	stop_sound();	disconnect_port();        System_PauseMidi_button->setText("Resume");  }  else {	connect_port();        snd_seq_continue_queue(seq, queue, NULL);        snd_seq_drain_output(seq);        snd_seq_get_queue_status(seq, queue, status);	current_tick = snd_seq_queue_status_get_tick_time(status);        System_PauseMidi_button->setText("Pause");        connect(JVlibForm::seqTimer, SIGNAL(timeout()), this, SLOT(tickDisplay()));	startPlayer(current_tick);        seqTimer->start(100);  }}   // end on_System_PauseMidi_button_toggled

void ALSADrv_MIDI_SetTempo(int tempo, int division){    double tps;    snd_seq_queue_tempo_t * t;    int result;    if (queueRunning) {        snd_seq_stop_queue(seq, seq_queue, NULL);        while ((result = snd_seq_drain_output(seq)) > 0) ;        if (result < 0) {            fprintf(stderr, "ALSA could not drain output: err %d/n", result);        }    }    snd_seq_queue_tempo_alloca(&t);    snd_seq_queue_tempo_set_tempo(t, 60000000 / tempo);    snd_seq_queue_tempo_set_ppq(t, division);    snd_seq_set_queue_tempo(seq, seq_queue, t);    tps = ( (double) tempo * (double) division ) / 60.0;    threadQueueTicks = (int) ceil(tps / (double) THREAD_QUEUE_INTERVAL);    if (queueRunning) {        snd_seq_start_queue(seq, seq_queue, NULL);        while ((result = snd_seq_drain_output(seq)) > 0) ;        if (result < 0) {            fprintf(stderr, "ALSA could not drain output: err %d/n", result);        }    }}

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 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 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 MidiQueue::enqueueMidiSyncEvents(const int sourcePort, bool includeMidiStart, bool includeSongPositionReset, unsigned int numberOfMidiClocks){	snd_seq_tick_time_t tick = 0;	if (includeMidiStart)	{		enqueueMidiMessage(SND_SEQ_EVENT_START, sourcePort, tick);		++tick;	}	if (includeSongPositionReset)	{		enqueueMidiMessage(SND_SEQ_EVENT_SONGPOS, sourcePort, tick);		++tick;	}	for (unsigned int eventIndex = 0; eventIndex < numberOfMidiClocks; ++eventIndex)	{		enqueueMidiMessage(SND_SEQ_EVENT_CLOCK, sourcePort, tick);		++tick;	}	int result = snd_seq_drain_output(_sequencer);	if (result < 0)	{		std::cerr << "MidiQueue::enqueueMidiSyncEvents error:" << snd_strerror(result) << std::endl;	}}

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 ALSADrv_MIDI_HaltPlayback(void){    int result;    void * ret;        if (!threadRunning) {        return;    }    threadQuit = 1;    if (pthread_join(thread, &ret)) {        fprintf(stderr, "ALSA pthread_join returned error/n");    }    if (queueRunning) {        //snd_seq_stop_queue(seq, seq_queue, NULL);    }    while ((result = snd_seq_drain_output(seq)) > 0) ;    if (result < 0) {        fprintf(stderr, "ALSA could not drain output: err %d/n", result);    }    snd_seq_sync_output_queue(seq);    //queueRunning = 0;    threadRunning = 0;}

/** del_aubio_alsa_seq_driver */int del_aubio_alsa_seq_driver(aubio_midi_driver_t* p){    aubio_alsa_seq_driver_t* dev;    dev = (aubio_alsa_seq_driver_t*) p;    if (dev == NULL) {        return AUBIO_OK;    }    dev->status = AUBIO_MIDI_DONE;    /* cancel the thread and wait for it before cleaning up */    if (dev->thread) {        if (pthread_cancel(dev->thread)) {            AUBIO_ERR( "Failed to cancel the midi thread");            return AUBIO_FAIL;        }        if (pthread_join(dev->thread, NULL)) {            AUBIO_ERR( "Failed to join the midi thread");            return AUBIO_FAIL;        }    }    if (dev->seq_port >= 0) {        snd_seq_delete_simple_port (dev->seq_handle, dev->seq_port);    }    if (dev->seq_handle) {        snd_seq_drain_output(dev->seq_handle);        snd_seq_close(dev->seq_handle);    }    AUBIO_FREE(dev);    return AUBIO_OK;}

    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);    }

static voidnote_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 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);}

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:%[email
C++ snd_seq_ev_clear函数代码示例
C++ snd_seq_close函数代码示例