Lines Matching refs:seq
2 * \file seq/seq.c
9 * See \ref seq page for more details.
31 /*! \page seq Sequencer interface
615 void capture_keyboard(snd_seq_t *seq)
629 snd_seq_subscribe_port(seq, subs);
638 void subscribe_output(snd_seq_t *seq)
649 snd_seq_subscribe_port(seq, subs);
654 void subscribe_output(snd_seq_t *seq)
656 snd_seq_connect_to(seq, 0, 65, 1);
672 void coupling(snd_seq_t *seq)
683 snd_seq_subscribe_port(seq, subs);
715 void schedule_event(snd_seq_t *seq)
725 snd_seq_event_output(seq, &ev);
727 snd_seq_drain_output(seq); // if necessary
740 void direct_delivery(snd_seq_t *seq)
750 snd_seq_event_output(seq, &ev);
751 snd_seq_drain_output(seq);
764 void event_filter(snd_seq_t *seq, snd_seq_event_t *ev)
766 while (snd_seq_event_input(seq, &ev) >= 0) {
772 snd_seq_event_output(seq, ev);
773 snd_seq_drain_output(seq);
785 * seq.h *
792 * \param seq sequencer handle
800 const char *snd_seq_name(snd_seq_t *seq)
802 assert(seq);
803 return seq->name;
808 * \param seq sequencer handle
815 snd_seq_type_t snd_seq_type(snd_seq_t *seq)
817 assert(seq);
818 return seq->type;
933 err = snd_config_search_definition(root, "seq", name, &seq_conf);
1032 * \param seq Handle returned from #snd_seq_open()
1043 int snd_seq_close(snd_seq_t *seq)
1046 assert(seq);
1047 err = seq->ops->close(seq);
1048 if (seq->dl_handle)
1049 snd_dlclose(seq->dl_handle);
1050 free(seq->obuf);
1051 free(seq->ibuf);
1052 free(seq->tmpbuf);
1053 free(seq->name);
1054 free(seq);
1060 * \param seq sequencer handle
1070 int snd_seq_poll_descriptors_count(snd_seq_t *seq, short events)
1073 assert(seq);
1075 assert(seq->streams & SND_SEQ_OPEN_INPUT);
1079 assert(seq->streams & SND_SEQ_OPEN_OUTPUT);
1087 * \param seq sequencer handle
1103 int snd_seq_poll_descriptors(snd_seq_t *seq, struct pollfd *pfds, unsigned int space, short events)
1107 assert(seq);
1109 assert(seq->streams & SND_SEQ_OPEN_INPUT);
1113 assert(seq->streams & SND_SEQ_OPEN_OUTPUT);
1118 pfds->fd = seq->poll_fd;
1125 * \param seq sequencer handle
1133 int snd_seq_poll_descriptors_revents(snd_seq_t *seq, struct pollfd *pfds, unsigned int nfds, unsigned short *revents)
1135 assert(seq && pfds && revents);
1145 * \param seq sequencer handle
1156 int snd_seq_nonblock(snd_seq_t *seq, int nonblock)
1159 assert(seq);
1160 err = seq->ops->nonblock(seq, nonblock);
1164 seq->mode |= SND_SEQ_NONBLOCK;
1166 seq->mode &= ~SND_SEQ_NONBLOCK;
1172 * \param seq sequencer handle
1182 int snd_seq_client_id(snd_seq_t *seq)
1184 assert(seq);
1185 return seq->client;
1190 * \param seq sequencer handle
1199 size_t snd_seq_get_output_buffer_size(snd_seq_t *seq)
1201 assert(seq);
1202 if (!seq->obuf)
1204 return seq->obufsize;
1207 static inline size_t get_packet_size(snd_seq_t *seq)
1209 return seq->packet_size ? seq->packet_size : sizeof(snd_seq_event_t);
1214 * \param seq sequencer handle
1222 size_t snd_seq_get_input_buffer_size(snd_seq_t *seq)
1224 assert(seq);
1225 if (!seq->ibuf)
1227 return seq->ibufsize * get_packet_size(seq);
1232 * \param seq sequencer handle
1240 int snd_seq_set_output_buffer_size(snd_seq_t *seq, size_t size)
1242 assert(seq && seq->obuf);
1244 snd_seq_drop_output(seq);
1245 if (size != seq->obufsize) {
1250 free(seq->obuf);
1251 seq->obuf = newbuf;
1252 seq->obufsize = size;
1259 * \param seq sequencer handle
1267 int snd_seq_set_input_buffer_size(snd_seq_t *seq, size_t size)
1271 assert(seq && seq->ibuf);
1272 packet_size = get_packet_size(seq);
1274 snd_seq_drop_input(seq);
1276 if (size != seq->ibufsize) {
1282 free(seq->ibuf);
1283 seq->ibuf = newbuf;
1284 seq->ibufsize = size;
1414 * \param seq sequencer handle
1422 int snd_seq_system_info(snd_seq_t *seq, snd_seq_system_info_t * info)
1424 assert(seq && info);
1425 return seq->ops->system_info(seq, info);
1592 * int is_get_card_or_pid_supported(snd_seq_t *seq)
1596 * snd_seq_get_client_info(seq, my_client_info);
1947 * \param seq sequencer handle
1958 int snd_seq_get_any_client_info(snd_seq_t *seq, int client, snd_seq_client_info_t *info)
1960 assert(seq && info && client >= 0);
1963 return seq->ops->get_client_info(seq, info);
1968 * \param seq sequencer handle
1978 int snd_seq_get_client_info(snd_seq_t *seq, snd_seq_client_info_t *info)
1980 return snd_seq_get_any_client_info(seq, seq->client, info);
1985 * \param seq sequencer handle
1994 int snd_seq_set_client_info(snd_seq_t *seq, snd_seq_client_info_t *info)
1996 assert(seq && info);
1997 info->client = seq->client;
1999 return seq->ops->set_client_info(seq, info);
2004 * \param seq sequencer handle
2016 int snd_seq_query_next_client(snd_seq_t *seq, snd_seq_client_info_t *info)
2018 assert(seq && info);
2019 return seq->ops->query_next_client(seq, info);
2024 * \param seq sequencer handle
2029 int snd_seq_get_ump_endpoint_info(snd_seq_t *seq, int client, void *info)
2031 assert(seq && info);
2032 return seq->ops->get_ump_info(seq, client,
2039 * \param seq sequencer handle
2045 int snd_seq_get_ump_block_info(snd_seq_t *seq, int client, int blk, void *info)
2047 assert(seq && info);
2048 return seq->ops->get_ump_info(seq, client,
2055 * \param seq sequencer handle
2059 int snd_seq_set_ump_endpoint_info(snd_seq_t *seq, const void *info)
2061 assert(seq && info);
2062 return seq->ops->set_ump_info(seq,
2069 * \param seq sequencer handle
2074 int snd_seq_set_ump_block_info(snd_seq_t *seq, int blk, const void *info)
2076 assert(seq && info);
2077 return seq->ops->set_ump_info(seq,
2560 * \param seq sequencer handle
2603 int snd_seq_create_port(snd_seq_t *seq, snd_seq_port_info_t * port)
2605 assert(seq && port);
2606 port->addr.client = seq->client;
2607 return seq->ops->create_port(seq, port);
2612 * \param seq sequencer handle
2620 int snd_seq_delete_port(snd_seq_t *seq, int port)
2623 assert(seq);
2625 pinfo.addr.client = seq->client;
2627 return seq->ops->delete_port(seq, &pinfo);
2632 * \param seq sequencer handle
2640 int snd_seq_get_any_port_info(snd_seq_t *seq, int client, int port, snd_seq_port_info_t * info)
2642 assert(seq && info && client >= 0 && port >= 0);
2646 return seq->ops->get_port_info(seq, info);
2651 * \param seq sequencer handle
2659 int snd_seq_get_port_info(snd_seq_t *seq, int port, snd_seq_port_info_t * info)
2661 return snd_seq_get_any_port_info(seq, seq->client, port, info);
2666 * \param seq sequencer handle
2673 int snd_seq_set_port_info(snd_seq_t *seq, int port, snd_seq_port_info_t * info)
2675 assert(seq && info && port >= 0);
2676 info->addr.client = seq->client;
2678 return seq->ops->set_port_info(seq, info);
2683 * \param seq sequencer handle
2698 int snd_seq_query_next_port(snd_seq_t *seq, snd_seq_port_info_t *info)
2700 assert(seq && info);
2701 return seq->ops->query_next_port(seq, info);
2922 * \param seq sequencer handle
2928 int snd_seq_get_port_subscription(snd_seq_t *seq, snd_seq_port_subscribe_t * sub)
2930 assert(seq && sub);
2931 return seq->ops->get_port_subscription(seq, sub);
2936 * \param seq sequencer handle
2946 int snd_seq_subscribe_port(snd_seq_t *seq, snd_seq_port_subscribe_t * sub)
2948 assert(seq && sub);
2949 return seq->ops->subscribe_port(seq, sub);
2954 * \param seq sequencer handle
2963 int snd_seq_unsubscribe_port(snd_seq_t *seq, snd_seq_port_subscribe_t * sub)
2965 assert(seq && sub);
2966 return seq->ops->unsubscribe_port(seq, sub);
3225 * \param seq sequencer handle
3242 int snd_seq_query_port_subscribers(snd_seq_t *seq, snd_seq_query_subscribe_t * subs)
3244 assert(seq && subs);
3245 return seq->ops->query_port_subscribers(seq, subs);
3418 * \param seq sequencer handle
3424 int snd_seq_create_queue(snd_seq_t *seq, snd_seq_queue_info_t *info)
3427 assert(seq && info);
3428 info->owner = seq->client;
3429 err = seq->ops->create_queue(seq, info);
3437 * \param seq sequencer handle
3443 int snd_seq_alloc_named_queue(snd_seq_t *seq, const char *name)
3450 return snd_seq_create_queue(seq, &info);
3455 * \param seq sequencer handle
3461 int snd_seq_alloc_queue(snd_seq_t *seq)
3463 return snd_seq_alloc_named_queue(seq, NULL);
3468 * \param seq sequencer handle
3474 int snd_seq_free_queue(snd_seq_t *seq, int q)
3477 assert(seq);
3480 return seq->ops->delete_queue(seq, &info);
3485 * \param seq sequencer handle
3492 int snd_seq_get_queue_info(snd_seq_t *seq, int q, snd_seq_queue_info_t *info)
3494 assert(seq && info);
3496 return seq->ops->get_queue_info(seq, info);
3501 * \param seq sequencer handle
3508 int snd_seq_set_queue_info(snd_seq_t *seq, int q, snd_seq_queue_info_t *info)
3510 assert(seq && info);
3512 return seq->ops->set_queue_info(seq, info);
3517 * \param seq sequencer handle
3525 int snd_seq_query_named_queue(snd_seq_t *seq, const char *name)
3529 assert(seq && name);
3531 err = seq->ops->get_named_queue(seq, &info);
3539 * \param seq sequencer handle
3546 int snd_seq_get_queue_usage(snd_seq_t *seq, int q)
3550 assert(seq);
3553 info.client = seq->client;
3554 if ((err = seq->ops->get_queue_client(seq, &info)) < 0)
3561 * \param seq sequencer handle
3568 int snd_seq_set_queue_usage(snd_seq_t *seq, int q, int used)
3571 assert(seq);
3574 info.client = seq->client;
3576 return seq->ops->set_queue_client(seq, &info);
3691 * \param seq sequencer handle
3698 int snd_seq_get_queue_status(snd_seq_t *seq, int q, snd_seq_queue_status_t * status)
3700 assert(seq && status);
3703 return seq->ops->get_queue_status(seq, status);
3873 * \param seq sequencer handle
3880 int snd_seq_get_queue_tempo(snd_seq_t *seq, int q, snd_seq_queue_tempo_t * tempo)
3882 assert(seq && tempo);
3885 return seq->ops->get_queue_tempo(seq, tempo);
3890 * \param seq sequencer handle
3897 int snd_seq_set_queue_tempo(snd_seq_t *seq, int q, snd_seq_queue_tempo_t * tempo)
3899 assert(seq && tempo);
3901 return seq->ops->set_queue_tempo(seq, tempo);
4045 * \param seq sequencer handle
4052 int snd_seq_get_queue_timer(snd_seq_t *seq, int q, snd_seq_queue_timer_t * timer)
4054 assert(seq && timer);
4057 return seq->ops->get_queue_timer(seq, timer);
4062 * \param seq sequencer handle
4069 int snd_seq_set_queue_timer(snd_seq_t *seq, int q, snd_seq_queue_timer_t * timer)
4071 assert(seq && timer);
4073 return seq->ops->set_queue_timer(seq, timer);
4134 * \param seq sequencer handle
4150 int snd_seq_event_output(snd_seq_t *seq, snd_seq_event_t *ev)
4154 result = snd_seq_event_output_buffer(seq, ev);
4156 result = snd_seq_drain_output(seq);
4159 return snd_seq_event_output_buffer(seq, ev);
4165 static void clear_ump_for_legacy_apps(snd_seq_t *seq, snd_seq_event_t *ev)
4167 if (!seq->midi_version && snd_seq_ev_is_ump(ev))
4173 * \param seq sequencer handle
4184 int snd_seq_event_output_buffer(snd_seq_t *seq, snd_seq_event_t *ev)
4187 assert(seq && ev);
4188 clear_ump_for_legacy_apps(seq, ev);
4192 if ((size_t) len >= seq->obufsize)
4194 if ((seq->obufsize - seq->obufused) < (size_t) len)
4197 memcpy(seq->obuf + seq->obufused, ev, sizeof(snd_seq_ump_event_t));
4199 memcpy(seq->obuf + seq->obufused, ev, sizeof(snd_seq_event_t));
4201 memcpy(seq->obuf + seq->obufused + sizeof(snd_seq_event_t),
4204 seq->obufused += len;
4205 return seq->obufused;
4211 static int alloc_tmpbuf(snd_seq_t *seq, size_t len)
4214 if (seq->tmpbuf == NULL) {
4216 seq->tmpbufsize = size;
4218 seq->tmpbufsize = DEFAULT_TMPBUF_SIZE;
4219 seq->tmpbuf = malloc(seq->tmpbufsize * sizeof(snd_seq_event_t));
4220 if (seq->tmpbuf == NULL)
4222 } else if (len > seq->tmpbufsize) {
4223 seq->tmpbuf = realloc(seq->tmpbuf, size * sizeof(snd_seq_event_t));
4224 if (seq->tmpbuf == NULL)
4226 seq->tmpbufsize = size;
4233 * \param seq sequencer handle
4244 int snd_seq_event_output_direct(snd_seq_t *seq, snd_seq_event_t *ev)
4249 clear_ump_for_legacy_apps(seq, ev);
4256 if (alloc_tmpbuf(seq, (size_t)len) < 0)
4258 *seq->tmpbuf = *ev;
4259 memcpy(seq->tmpbuf + 1, ev->data.ext.ptr, ev->data.ext.len);
4260 buf = seq->tmpbuf;
4262 return seq->ops->write(seq, buf, (size_t) len);
4267 * \param seq sequencer handle
4272 int snd_seq_event_output_pending(snd_seq_t *seq)
4274 assert(seq);
4275 return seq->obufused;
4280 * \param seq sequencer handle
4293 int snd_seq_drain_output(snd_seq_t *seq)
4296 assert(seq);
4297 while (seq->obufused > 0) {
4298 result = seq->ops->write(seq, seq->obuf, seq->obufused);
4301 return seq->obufused;
4304 if ((size_t)result < seq->obufused)
4305 memmove(seq->obuf, seq->obuf + result, seq->obufused - result);
4306 seq->obufused -= result;
4313 * \param seq sequencer handle
4322 int snd_seq_extract_output(snd_seq_t *seq, snd_seq_event_t **ev_res)
4325 assert(seq);
4328 if ((olen = seq->obufused) < sizeof(snd_seq_event_t))
4330 len = snd_seq_event_length((snd_seq_event_t *)seq->obuf);
4335 if (alloc_tmpbuf(seq, len) < 0)
4337 memcpy(seq->tmpbuf, seq->obuf, len);
4338 *ev_res = (snd_seq_event_t *)seq->tmpbuf;
4340 seq->obufused = olen - len;
4341 memmove(seq->obuf, seq->obuf + len, seq->obufused);
4354 static ssize_t snd_seq_event_read_buffer(snd_seq_t *seq)
4356 size_t packet_size = get_packet_size(seq);
4359 len = (seq->ops->read)(seq, seq->ibuf, seq->ibufsize * packet_size);
4362 seq->ibuflen = len / packet_size;
4363 seq->ibufptr = 0;
4364 return seq->ibuflen;
4367 static int snd_seq_event_retrieve_buffer(snd_seq_t *seq, snd_seq_event_t **retp)
4369 size_t packet_size = get_packet_size(seq);
4373 *retp = ev = (snd_seq_event_t *)(seq->ibuf + seq->ibufptr * packet_size);
4374 clear_ump_for_legacy_apps(seq, ev);
4375 seq->ibufptr++;
4376 seq->ibuflen--;
4380 if (seq->ibuflen < ncells) {
4381 seq->ibuflen = 0; /* clear buffer */
4386 seq->ibuflen -= ncells;
4387 seq->ibufptr += ncells;
4393 * \param seq sequencer handle
4421 int snd_seq_event_input(snd_seq_t *seq, snd_seq_event_t **ev)
4424 assert(seq);
4426 if (seq->ibuflen <= 0) {
4427 if ((err = snd_seq_event_read_buffer(seq)) < 0)
4431 return snd_seq_event_retrieve_buffer(seq, ev);
4437 static int snd_seq_event_input_feed(snd_seq_t *seq, int timeout)
4441 pfd.fd = seq->poll_fd;
4449 return snd_seq_event_read_buffer(seq);
4450 return seq->ibuflen;
4468 int snd_seq_event_input_pending(snd_seq_t *seq, int fetch_sequencer)
4470 if (seq->ibuflen == 0 && fetch_sequencer) {
4471 return snd_seq_event_input_feed(seq, 0);
4473 return seq->ibuflen;
4484 * \param seq sequencer handle
4500 int snd_seq_ump_event_output(snd_seq_t *seq, snd_seq_ump_event_t *ev)
4502 if (!seq->midi_version)
4504 return snd_seq_event_output(seq, (snd_seq_event_t *)ev);
4509 * \param seq sequencer handle
4517 int snd_seq_ump_event_output_buffer(snd_seq_t *seq, snd_seq_ump_event_t *ev)
4519 if (!seq->midi_version)
4521 return snd_seq_event_output_buffer(seq, (snd_seq_event_t *)ev);
4526 * \param seq sequencer handle
4534 int snd_seq_ump_extract_output(snd_seq_t *seq, snd_seq_ump_event_t **ev_res)
4536 if (!seq->midi_version)
4538 return snd_seq_extract_output(seq, (snd_seq_event_t **)ev_res);
4543 * \param seq sequencer handle
4551 int snd_seq_ump_event_output_direct(snd_seq_t *seq, snd_seq_ump_event_t *ev)
4553 if (!seq->midi_version)
4555 return snd_seq_event_output_direct(seq, (snd_seq_event_t *)ev);
4560 * \param seq sequencer handle
4574 int snd_seq_ump_event_input(snd_seq_t *seq, snd_seq_ump_event_t **ev)
4576 if (!seq->midi_version)
4578 return snd_seq_event_input(seq, (snd_seq_event_t **)ev);
4589 * \param seq sequencer handle
4597 int snd_seq_drop_output_buffer(snd_seq_t *seq)
4599 assert(seq);
4600 seq->obufused = 0;
4606 * \param seq sequencer handle
4610 int snd_seq_drop_input_buffer(snd_seq_t *seq)
4612 assert(seq);
4613 seq->ibufptr = 0;
4614 seq->ibuflen = 0;
4620 * \param seq sequencer handle
4627 int snd_seq_drop_output(snd_seq_t *seq)
4630 assert(seq);
4635 return snd_seq_remove_events(seq, &rminfo);
4640 * \param seq sequencer handle
4644 int snd_seq_drop_input(snd_seq_t *seq)
4647 assert(seq);
4652 return snd_seq_remove_events(seq, &rminfo);
4958 * \param seq sequencer handle
4967 int snd_seq_remove_events(snd_seq_t *seq, snd_seq_remove_events_t *rmp)
4974 snd_seq_drop_input_buffer(seq);
4984 snd_seq_drop_output_buffer(seq);
4990 ep = seq->obuf;
4991 while (ep - seq->obuf < (ssize_t)seq->obufused) {
4998 seq->obufused -= len;
4999 memmove(ep, ep + len, seq->obufused - (ep - seq->obuf));
5007 return seq->ops->remove_events(seq, rmp);
5162 * \param seq sequencer handle
5165 int snd_seq_get_client_pool(snd_seq_t *seq, snd_seq_client_pool_t *info)
5167 assert(seq && info);
5168 info->client = seq->client;
5169 return seq->ops->get_client_pool(seq, info);
5174 * \param seq sequencer handle
5180 int snd_seq_set_client_pool(snd_seq_t *seq, snd_seq_client_pool_t *info)
5182 assert(seq && info);
5183 info->client = seq->client;
5184 return seq->ops->set_client_pool(seq, info);