Lines Matching defs:events
36 events between clients/ports.
40 application can handle incoming or outgoing MIDI events regardless of
44 scheduling events and dispatching them to the destination at the
45 right time. All processing of MIDI events has to be done within the clients.
100 for each input and output events.
104 it avoids such a situation that a client eats the whole events pool
107 The all scheduled output events or input events from dispatcher are stored
131 Suppose a MIDI input device which sends events from a keyboard.
134 If a user program wants to capture events from keyboard and store them
138 From this time, events from keyboard are automatically sent to this program.
151 Suppose a MIDI sequencer program which sends events to a MIDI output device.
155 After this connection is established, events will be properly sent
161 ALSA sequencer - events are scheduled
170 the MIDI events like program, velocity or chorus effects.
175 in order to process the MIDI events.
179 only input and output events regardless of receiver/sender addresses.
194 Messaging between clients is performed by sending events from one client to
195 another. These events contain high-level MIDI oriented messages or sequencer
198 All the sequencer events are stored in a sequencer event record,
286 Note that the time format used for real time events is very similar to
300 As each sequencer queue has it's own clock the only way to deliver events at
338 This port supports subscription. The received timer events are
347 Some events like SYSEX message, however, need larger data space
349 For such events, ALSA sequencer provides several different data storage types.
354 Normal events stores their parameters on
517 The former means that the port allows to send events to other ports,
519 that the port allows to receive events from other ports.
600 This feature is useful when receiving events from MIDI input device.
691 Now, two ports are connected by subscription. Then how to send events?
1061 * \param events the poll events to be checked (\c POLLIN and \c POLLOUT)
1064 * Get the number of poll descriptors. The polling events to be checked
1070 int snd_seq_poll_descriptors_count(snd_seq_t *seq, short events)
1074 if (events & POLLIN) {
1078 if (events & POLLOUT) {
1090 * \param events polling events to be checked (\c POLLIN and \c POLLOUT)
1095 * is/are polled in \a events argument. When \c POLLIN bit is specified,
1096 * the incoming events to the ports are checked.
1098 * To check the returned poll-events, call #snd_seq_poll_descriptors_revents()
1103 int snd_seq_poll_descriptors(snd_seq_t *seq, struct pollfd *pfds, unsigned int space, short events)
1108 if ((events & POLLIN) && space >= 1) {
1112 if ((events & POLLOUT) && space >= 1) {
1119 pfds->events = revents;
1124 * \brief get returned events from poll descriptors
1128 * \param revents returned events
1151 * output memory pool with full events. The client will be woken up
1194 * This buffer is used to store decoded byte-stream of output events
1218 * This buffer is used to read byte-stream of input events from sequencer.
1726 * \brief Get the number of lost events of a client_info container
1728 * \return number of lost events
2292 * \return 1 if the port updates timestamps of incoming events
2490 * \param enable non-zero if updating the timestamps of incoming events
3638 * \brief Get the number of events of a queue_status container
3640 * \return number of events
3647 return info->events;
4136 * \return the number of remaining events or a negative error code
4141 * If events remain unprocessed on output buffer before drained,
4175 * \return the byte size of remaining events. \c -EAGAIN if the buffer becomes full.
4266 * \brief return the size of pending events on output buffer
4268 * \return the byte size of total of pending events
4281 * \return 0 when all events are drained and sent to sequencer.
4282 * When events still remain on the buffer, the byte size of remaining
4283 * events are returned. On error a negative error code is returned.
4285 * This function drains all pending events on the output buffer.
4286 * The function returns immediately after the events are sent to the queues
4287 * regardless whether the events are processed or not.
4404 * By calling this function sequentially, events are extracted from the input buffer.
4410 * This means that the input FIFO of sequencer overran, and some events are
4414 * Function returns the byte size of remaining events on the input buffer
4442 pfd.events = POLLIN;
4454 * \brief check events in input buffer
4455 * \return the byte size of remaining input events on input buffer.
4457 * If events remain on the input buffer of user-space, function returns
4458 * the total byte size of events on it.
4460 * this function checks the presence of events on sequencer FIFO
4461 * When events exist, they are transferred to the input buffer,
4462 * and the number of received events are returned.
4464 * no events remain on the input buffer, function simply returns zero.
4486 * \return the number of remaining events or a negative error code
4511 * \return the byte size of remaining events. \c -EAGAIN if the buffer becomes full.
4588 * \brief remove all events on user-space output buffer
4591 * Removes all events on user-space output buffer.
4593 * events on output memory pool of sequencer.
4605 * \brief remove all events on user-space input FIFO
4619 * \brief remove all events on output buffer
4622 * Removes all events on both user-space output buffer and
4639 * \brief clear input buffer and and remove events in sequencer queue
4883 /* compare timestamp between events */
4901 /* Routine to match events to be removed */
4939 /* Do not remove off events */
4957 * \brief remove events on input/output buffers and pools
4961 * Removes matching events with the given condition from input/output buffers
4971 * First deal with any events that are still buffered
4979 * First deal with any events that are still buffered