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;
841 SNDERR("Invalid type for SEQ %s definition", name);
843 SNDERR("Invalid type for SEQ definition");
864 SNDERR("Invalid type for SEQ type %s definition", str);
933 err = snd_config_search_definition(root, "seq", name, &seq_conf);
935 SNDERR("Unknown SEQ %s", name);
1022 * \param seq Handle returned from #snd_seq_open()
1033 int snd_seq_close(snd_seq_t *seq)
1036 assert(seq);
1037 err = seq->ops->close(seq);
1038 if (seq->dl_handle)
1039 snd_dlclose(seq->dl_handle);
1040 free(seq->obuf);
1041 free(seq->ibuf);
1042 free(seq->tmpbuf);
1043 free(seq->name);
1044 free(seq);
1050 * \param seq sequencer handle
1060 int snd_seq_poll_descriptors_count(snd_seq_t *seq, short events)
1063 assert(seq);
1065 assert(seq->streams & SND_SEQ_OPEN_INPUT);
1069 assert(seq->streams & SND_SEQ_OPEN_OUTPUT);
1077 * \param seq sequencer handle
1093 int snd_seq_poll_descriptors(snd_seq_t *seq, struct pollfd *pfds, unsigned int space, short events)
1097 assert(seq);
1099 assert(seq->streams & SND_SEQ_OPEN_INPUT);
1103 assert(seq->streams & SND_SEQ_OPEN_OUTPUT);
1108 pfds->fd = seq->poll_fd;
1115 * \param seq sequencer handle
1123 int snd_seq_poll_descriptors_revents(snd_seq_t *seq, struct pollfd *pfds, unsigned int nfds, unsigned short *revents)
1125 assert(seq && pfds && revents);
1135 * \param seq sequencer handle
1146 int snd_seq_nonblock(snd_seq_t *seq, int nonblock)
1149 assert(seq);
1150 err = seq->ops->nonblock(seq, nonblock);
1154 seq->mode |= SND_SEQ_NONBLOCK;
1156 seq->mode &= ~SND_SEQ_NONBLOCK;
1162 * \param seq sequencer handle
1172 int snd_seq_client_id(snd_seq_t *seq)
1174 assert(seq);
1175 return seq->client;
1180 * \param seq sequencer handle
1189 size_t snd_seq_get_output_buffer_size(snd_seq_t *seq)
1191 assert(seq);
1192 if (!seq->obuf)
1194 return seq->obufsize;
1199 * \param seq sequencer handle
1207 size_t snd_seq_get_input_buffer_size(snd_seq_t *seq)
1209 assert(seq);
1210 if (!seq->ibuf)
1212 return seq->ibufsize * sizeof(snd_seq_event_t);
1217 * \param seq sequencer handle
1225 int snd_seq_set_output_buffer_size(snd_seq_t *seq, size_t size)
1227 assert(seq && seq->obuf);
1229 snd_seq_drop_output(seq);
1230 if (size != seq->obufsize) {
1235 free(seq->obuf);
1236 seq->obuf = newbuf;
1237 seq->obufsize = size;
1244 * \param seq sequencer handle
1252 int snd_seq_set_input_buffer_size(snd_seq_t *seq, size_t size)
1254 assert(seq && seq->ibuf);
1256 snd_seq_drop_input(seq);
1258 if (size != seq->ibufsize) {
1263 free(seq->ibuf);
1264 seq->ibuf = newbuf;
1265 seq->ibufsize = size;
1395 * \param seq sequencer handle
1403 int snd_seq_system_info(snd_seq_t *seq, snd_seq_system_info_t * info)
1405 assert(seq && info);
1406 return seq->ops->system_info(seq, info);
1739 * \param seq sequencer handle
1750 int snd_seq_get_any_client_info(snd_seq_t *seq, int client, snd_seq_client_info_t *info)
1752 assert(seq && info && client >= 0);
1755 return seq->ops->get_client_info(seq, info);
1760 * \param seq sequencer handle
1770 int snd_seq_get_client_info(snd_seq_t *seq, snd_seq_client_info_t *info)
1772 return snd_seq_get_any_client_info(seq, seq->client, info);
1777 * \param seq sequencer handle
1786 int snd_seq_set_client_info(snd_seq_t *seq, snd_seq_client_info_t *info)
1788 assert(seq && info);
1789 info->client = seq->client;
1791 return seq->ops->set_client_info(seq, info);
1796 * \param seq sequencer handle
1808 int snd_seq_query_next_client(snd_seq_t *seq, snd_seq_client_info_t *info)
1810 assert(seq && info);
1811 return seq->ops->query_next_client(seq, info);
2242 * \param seq sequencer handle
2285 int snd_seq_create_port(snd_seq_t *seq, snd_seq_port_info_t * port)
2287 assert(seq && port);
2288 port->addr.client = seq->client;
2289 return seq->ops->create_port(seq, port);
2294 * \param seq sequencer handle
2302 int snd_seq_delete_port(snd_seq_t *seq, int port)
2305 assert(seq);
2307 pinfo.addr.client = seq->client;
2309 return seq->ops->delete_port(seq, &pinfo);
2314 * \param seq sequencer handle
2322 int snd_seq_get_any_port_info(snd_seq_t *seq, int client, int port, snd_seq_port_info_t * info)
2324 assert(seq && info && client >= 0 && port >= 0);
2328 return seq->ops->get_port_info(seq, info);
2333 * \param seq sequencer handle
2341 int snd_seq_get_port_info(snd_seq_t *seq, int port, snd_seq_port_info_t * info)
2343 return snd_seq_get_any_port_info(seq, seq->client, port, info);
2348 * \param seq sequencer handle
2355 int snd_seq_set_port_info(snd_seq_t *seq, int port, snd_seq_port_info_t * info)
2357 assert(seq && info && port >= 0);
2358 info->addr.client = seq->client;
2360 return seq->ops->set_port_info(seq, info);
2365 * \param seq sequencer handle
2380 int snd_seq_query_next_port(snd_seq_t *seq, snd_seq_port_info_t *info)
2382 assert(seq && info);
2383 return seq->ops->query_next_port(seq, info);
2604 * \param seq sequencer handle
2610 int snd_seq_get_port_subscription(snd_seq_t *seq, snd_seq_port_subscribe_t * sub)
2612 assert(seq && sub);
2613 return seq->ops->get_port_subscription(seq, sub);
2618 * \param seq sequencer handle
2628 int snd_seq_subscribe_port(snd_seq_t *seq, snd_seq_port_subscribe_t * sub)
2630 assert(seq && sub);
2631 return seq->ops->subscribe_port(seq, sub);
2636 * \param seq sequencer handle
2645 int snd_seq_unsubscribe_port(snd_seq_t *seq, snd_seq_port_subscribe_t * sub)
2647 assert(seq && sub);
2648 return seq->ops->unsubscribe_port(seq, sub);
2907 * \param seq sequencer handle
2924 int snd_seq_query_port_subscribers(snd_seq_t *seq, snd_seq_query_subscribe_t * subs)
2926 assert(seq && subs);
2927 return seq->ops->query_port_subscribers(seq, subs);
3100 * \param seq sequencer handle
3106 int snd_seq_create_queue(snd_seq_t *seq, snd_seq_queue_info_t *info)
3109 assert(seq && info);
3110 info->owner = seq->client;
3111 err = seq->ops->create_queue(seq, info);
3119 * \param seq sequencer handle
3125 int snd_seq_alloc_named_queue(snd_seq_t *seq, const char *name)
3132 return snd_seq_create_queue(seq, &info);
3137 * \param seq sequencer handle
3143 int snd_seq_alloc_queue(snd_seq_t *seq)
3145 return snd_seq_alloc_named_queue(seq, NULL);
3150 * \param seq sequencer handle
3156 int snd_seq_free_queue(snd_seq_t *seq, int q)
3159 assert(seq);
3162 return seq->ops->delete_queue(seq, &info);
3167 * \param seq sequencer handle
3174 int snd_seq_get_queue_info(snd_seq_t *seq, int q, snd_seq_queue_info_t *info)
3176 assert(seq && info);
3178 return seq->ops->get_queue_info(seq, info);
3183 * \param seq sequencer handle
3190 int snd_seq_set_queue_info(snd_seq_t *seq, int q, snd_seq_queue_info_t *info)
3192 assert(seq && info);
3194 return seq->ops->set_queue_info(seq, info);
3199 * \param seq sequencer handle
3207 int snd_seq_query_named_queue(snd_seq_t *seq, const char *name)
3211 assert(seq && name);
3213 err = seq->ops->get_named_queue(seq, &info);
3221 * \param seq sequencer handle
3228 int snd_seq_get_queue_usage(snd_seq_t *seq, int q)
3232 assert(seq);
3235 info.client = seq->client;
3236 if ((err = seq->ops->get_queue_client(seq, &info)) < 0)
3243 * \param seq sequencer handle
3250 int snd_seq_set_queue_usage(snd_seq_t *seq, int q, int used)
3253 assert(seq);
3256 info.client = seq->client;
3258 return seq->ops->set_queue_client(seq, &info);
3373 * \param seq sequencer handle
3380 int snd_seq_get_queue_status(snd_seq_t *seq, int q, snd_seq_queue_status_t * status)
3382 assert(seq && status);
3385 return seq->ops->get_queue_status(seq, status);
3555 * \param seq sequencer handle
3562 int snd_seq_get_queue_tempo(snd_seq_t *seq, int q, snd_seq_queue_tempo_t * tempo)
3564 assert(seq && tempo);
3567 return seq->ops->get_queue_tempo(seq, tempo);
3572 * \param seq sequencer handle
3579 int snd_seq_set_queue_tempo(snd_seq_t *seq, int q, snd_seq_queue_tempo_t * tempo)
3581 assert(seq && tempo);
3583 return seq->ops->set_queue_tempo(seq, tempo);
3727 * \param seq sequencer handle
3734 int snd_seq_get_queue_timer(snd_seq_t *seq, int q, snd_seq_queue_timer_t * timer)
3736 assert(seq && timer);
3739 return seq->ops->get_queue_timer(seq, timer);
3744 * \param seq sequencer handle
3751 int snd_seq_set_queue_timer(snd_seq_t *seq, int q, snd_seq_queue_timer_t * timer)
3753 assert(seq && timer);
3755 return seq->ops->set_queue_timer(seq, timer);
3814 * \param seq sequencer handle
3830 int snd_seq_event_output(snd_seq_t *seq, snd_seq_event_t *ev)
3834 result = snd_seq_event_output_buffer(seq, ev);
3836 result = snd_seq_drain_output(seq);
3839 return snd_seq_event_output_buffer(seq, ev);
3846 * \param seq sequencer handle
3854 int snd_seq_event_output_buffer(snd_seq_t *seq, snd_seq_event_t *ev)
3857 assert(seq && ev);
3861 if ((size_t) len >= seq->obufsize)
3863 if ((seq->obufsize - seq->obufused) < (size_t) len)
3865 memcpy(seq->obuf + seq->obufused, ev, sizeof(snd_seq_event_t));
3866 seq->obufused += sizeof(snd_seq_event_t);
3868 memcpy(seq->obuf + seq->obufused, ev->data.ext.ptr, ev->data.ext.len);
3869 seq->obufused += ev->data.ext.len;
3871 return seq->obufused;
3877 static int alloc_tmpbuf(snd_seq_t *seq, size_t len)
3880 if (seq->tmpbuf == NULL) {
3882 seq->tmpbufsize = size;
3884 seq->tmpbufsize = DEFAULT_TMPBUF_SIZE;
3885 seq->tmpbuf = malloc(seq->tmpbufsize * sizeof(snd_seq_event_t));
3886 if (seq->tmpbuf == NULL)
3888 } else if (len > seq->tmpbufsize) {
3889 seq->tmpbuf = realloc(seq->tmpbuf, size * sizeof(snd_seq_event_t));
3890 if (seq->tmpbuf == NULL)
3892 seq->tmpbufsize = size;
3899 * \param seq sequencer handle
3910 int snd_seq_event_output_direct(snd_seq_t *seq, snd_seq_event_t *ev)
3921 if (alloc_tmpbuf(seq, (size_t)len) < 0)
3923 *seq->tmpbuf = *ev;
3924 memcpy(seq->tmpbuf + 1, ev->data.ext.ptr, ev->data.ext.len);
3925 buf = seq->tmpbuf;
3927 return seq->ops->write(seq, buf, (size_t) len);
3932 * \param seq sequencer handle
3937 int snd_seq_event_output_pending(snd_seq_t *seq)
3939 assert(seq);
3940 return seq->obufused;
3945 * \param seq sequencer handle
3958 int snd_seq_drain_output(snd_seq_t *seq)
3961 assert(seq);
3962 while (seq->obufused > 0) {
3963 result = seq->ops->write(seq, seq->obuf, seq->obufused);
3966 return seq->obufused;
3969 if ((size_t)result < seq->obufused)
3970 memmove(seq->obuf, seq->obuf + result, seq->obufused - result);
3971 seq->obufused -= result;
3978 * \param seq sequencer handle
3987 int snd_seq_extract_output(snd_seq_t *seq, snd_seq_event_t **ev_res)
3991 assert(seq);
3994 if ((olen = seq->obufused) < sizeof(snd_seq_event_t))
3996 memcpy(&ev, seq->obuf, sizeof(snd_seq_event_t));
4000 if (alloc_tmpbuf(seq, len) < 0)
4002 memcpy(seq->tmpbuf, seq->obuf, len);
4003 *ev_res = seq->tmpbuf;
4005 seq->obufused = olen - len;
4006 memmove(seq->obuf, seq->obuf + len, seq->obufused);
4019 static ssize_t snd_seq_event_read_buffer(snd_seq_t *seq)
4022 len = (seq->ops->read)(seq, seq->ibuf, seq->ibufsize * sizeof(snd_seq_event_t));
4025 seq->ibuflen = len / sizeof(snd_seq_event_t);
4026 seq->ibufptr = 0;
4027 return seq->ibuflen;
4030 static int snd_seq_event_retrieve_buffer(snd_seq_t *seq, snd_seq_event_t **retp)
4035 *retp = ev = &seq->ibuf[seq->ibufptr];
4036 seq->ibufptr++;
4037 seq->ibuflen--;
4041 if (seq->ibuflen < ncells) {
4042 seq->ibuflen = 0; /* clear buffer */
4047 seq->ibuflen -= ncells;
4048 seq->ibufptr += ncells;
4054 * \param seq sequencer handle
4082 int snd_seq_event_input(snd_seq_t *seq, snd_seq_event_t **ev)
4085 assert(seq);
4087 if (seq->ibuflen <= 0) {
4088 if ((err = snd_seq_event_read_buffer(seq)) < 0)
4092 return snd_seq_event_retrieve_buffer(seq, ev);
4098 static int snd_seq_event_input_feed(snd_seq_t *seq, int timeout)
4102 pfd.fd = seq->poll_fd;
4110 return snd_seq_event_read_buffer(seq);
4111 return seq->ibuflen;
4129 int snd_seq_event_input_pending(snd_seq_t *seq, int fetch_sequencer)
4131 if (seq->ibuflen == 0 && fetch_sequencer) {
4132 return snd_seq_event_input_feed(seq, 0);
4134 return seq->ibuflen;
4145 * \param seq sequencer handle
4153 int snd_seq_drop_output_buffer(snd_seq_t *seq)
4155 assert(seq);
4156 seq->obufused = 0;
4162 * \param seq sequencer handle
4166 int snd_seq_drop_input_buffer(snd_seq_t *seq)
4168 assert(seq);
4169 seq->ibufptr = 0;
4170 seq->ibuflen = 0;
4176 * \param seq sequencer handle
4183 int snd_seq_drop_output(snd_seq_t *seq)
4186 assert(seq);
4191 return snd_seq_remove_events(seq, &rminfo);
4196 * \param seq sequencer handle
4200 int snd_seq_drop_input(snd_seq_t *seq)
4203 assert(seq);
4208 return snd_seq_remove_events(seq, &rminfo);
4514 * \param seq sequencer handle
4523 int snd_seq_remove_events(snd_seq_t *seq, snd_seq_remove_events_t *rmp)
4530 snd_seq_drop_input_buffer(seq);
4540 snd_seq_drop_output_buffer(seq);
4546 ep = seq->obuf;
4547 while (ep - seq->obuf < (ssize_t)seq->obufused) {
4554 seq->obufused -= len;
4555 memmove(ep, ep + len, seq->obufused - (ep - seq->obuf));
4563 return seq->ops->remove_events(seq, rmp);
4718 * \param seq sequencer handle
4721 int snd_seq_get_client_pool(snd_seq_t *seq, snd_seq_client_pool_t *info)
4723 assert(seq && info);
4724 info->client = seq->client;
4725 return seq->ops->get_client_pool(seq, info);
4730 * \param seq sequencer handle
4736 int snd_seq_set_client_pool(snd_seq_t *seq, snd_seq_client_pool_t *info)
4738 assert(seq && info);
4739 info->client = seq->client;
4740 return seq->ops->set_client_pool(seq, info);
