Lines Matching full:info
1317 * \param info #snd_seq_system_info_t container
1322 int snd_seq_system_info_get_queues(const snd_seq_system_info_t *info)
1324 assert(info);
1325 return info->queues;
1330 * \param info #snd_seq_system_info_t container
1335 int snd_seq_system_info_get_clients(const snd_seq_system_info_t *info)
1337 assert(info);
1338 return info->clients;
1343 * \param info #snd_seq_system_info_t container
1348 int snd_seq_system_info_get_ports(const snd_seq_system_info_t *info)
1350 assert(info);
1351 return info->ports;
1356 * \param info #snd_seq_system_info_t container
1361 int snd_seq_system_info_get_channels(const snd_seq_system_info_t *info)
1363 assert(info);
1364 return info->channels;
1369 * \param info #snd_seq_system_info_t container
1374 int snd_seq_system_info_get_cur_clients(const snd_seq_system_info_t *info)
1376 assert(info);
1377 return info->cur_clients;
1382 * \param info #snd_seq_system_info_t container
1387 int snd_seq_system_info_get_cur_queues(const snd_seq_system_info_t *info)
1389 assert(info);
1390 return info->cur_queues;
1396 * \param info the pointer to be stored
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);
1458 * \param info client_info container
1463 int snd_seq_client_info_get_client(const snd_seq_client_info_t *info)
1465 assert(info);
1466 return info->client;
1471 * \param info client_info container
1479 snd_seq_client_type_t snd_seq_client_info_get_type(const snd_seq_client_info_t *info)
1481 assert(info);
1482 return info->type;
1487 * \param info client_info container
1492 const char *snd_seq_client_info_get_name(snd_seq_client_info_t *info)
1494 assert(info);
1495 return info->name;
1500 * \param info client_info container
1505 int snd_seq_client_info_get_broadcast_filter(const snd_seq_client_info_t *info)
1507 assert(info);
1508 return (info->filter & SNDRV_SEQ_FILTER_BROADCAST) ? 1 : 0;
1513 * \param info client_info container
1518 int snd_seq_client_info_get_error_bounce(const snd_seq_client_info_t *info)
1520 assert(info);
1521 return (info
1526 * \param info client_info container
1537 const unsigned char *snd_seq_client_info_get_event_filter(const snd_seq_client_info_t *info)
1539 assert(info);
1540 if (info->filter & SNDRV_SEQ_FILTER_USE_EVENT)
1541 return info->event_filter;
1548 * \param info client_info container
1559 void snd_seq_client_info_event_filter_clear(snd_seq_client_info_t *info)
1561 assert(info);
1562 info->filter &= ~SNDRV_SEQ_FILTER_USE_EVENT;
1563 memset(info->event_filter, 0, sizeof(info->event_filter));
1568 * \param info client_info container
1580 void snd_seq_client_info_event_filter_add(snd_seq_client_info_t *info, int event_type)
1582 assert(info);
1583 info->filter |= SNDRV_SEQ_FILTER_USE_EVENT;
1584 snd_seq_set_bit(event_type, info->event_filter);
1589 * \param info client_info container
1601 void snd_seq_client_info_event_filter_del(snd_seq_client_info_t *info, int event_type)
1603 assert(info);
1604 snd_seq_unset_bit(event_type, info->event_filter);
1609 * \param info client_info container
1621 int snd_seq_client_info_event_filter_check(snd_seq_client_info_t *info, int event_type)
1623 assert(info);
1624 return snd_seq_get_bit(event_type, info->event_filter);
1629 * \param info client_info container
1634 int snd_seq_client_info_get_num_ports(const snd_seq_client_info_t *info)
1636 assert(info);
1637 return info->num_ports;
1642 * \param info client_info container
1647 int snd_seq_client_info_get_event_lost(const snd_seq_client_info_t *info)
1649 assert(info);
1650 return info->event_lost;
1655 * \param info client_info container
1660 void snd_seq_client_info_set_client(snd_seq_client_info_t *info, int client)
1662 assert(info);
1663 info->client = client;
1668 * \param info client_info container
1674 void snd_seq_client_info_set_name(snd_seq_client_info_t *info, const char *name)
1676 assert(info && name);
1677 strncpy(info->name, name, sizeof(info->name));
1682 * \param info client_info container
1687 void snd_seq_client_info_set_broadcast_filter(snd_seq_client_info_t *info, int val)
1689 assert(info);
1691 info->filter |= SNDRV_SEQ_FILTER_BROADCAST;
1693 info->filter &= ~SNDRV_SEQ_FILTER_BROADCAST;
1698 * \param info client_info container
1703 void snd_seq_client_info_set_error_bounce(snd_seq_client_info_t *info, int val)
1705 assert(info);
1707 info->filter |= SNDRV_SEQ_FILTER_BOUNCE;
1709 info->filter &= ~SNDRV_SEQ_FILTER_BOUNCE;
1714 * \param info client_info container
1725 void snd_seq_client_info_set_event_filter(snd_seq_client_info_t *info, unsigned char *filter)
1727 assert(info);
1729 info->filter &= ~SNDRV_SEQ_FILTER_USE_EVENT;
1731 info->filter |= SNDRV_SEQ_FILTER_USE_EVENT;
1732 memcpy(info->event_filter, filter, sizeof(info->event_filter));
1741 * \param info the pointer to be stored
1745 * info argument.
1746 * The obtained information is written on info parameter.
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);
1753 memset(info, 0, sizeof(snd_seq_client_info_t));
1754 info->client = client;
1755 return seq->ops->get_client_info(seq, info);
1761 * \param info the pointer to be stored
1764 * Obtains the information of the current client stored on info.
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);
1778 * \param info the client info data to set
1781 * Obtains the information of the current client stored on info.
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;
1790 info->type = USER_CLIENT;
1791 return seq->ops->set_client_info(seq, info);
1797 * \param info query pattern and result
1801 * client field in info.
1802 * If a client is found, its attributes are stored in info,
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);
1868 * \param info port_info container
1873 int snd_seq_port_info_get_client(const snd_seq_port_info_t *info)
1875 assert(info);
1876 return info->addr.client;
1881 * \param info port_info container
1886 int snd_seq_port_info_get_port(const snd_seq_port_info_t *info)
1888 assert(info);
1889 return info->addr.port;
1894 * \param info port_info container
1899 const snd_seq_addr_t *snd_seq_port_info_get_addr(const snd_seq_port_info_t *info)
1901 assert(info);
1902 return &info->addr;
1907 * \param info port_info container
1912 const char *snd_seq_port_info_get_name(const snd_seq_port_info_t *info)
1914 assert(info);
1915 return info->name;
1920 * \param info port_info container
1925 unsigned int snd_seq_port_info_get_capability(const snd_seq_port_info_t *info)
1927 assert(info);
1928 return info->capability;
1933 * \param info port_info container
1938 unsigned int snd_seq_port_info_get_type(const snd_seq_port_info_t *info)
1940 assert(info);
1941 return info->type;
1946 * \param info port_info container
1951 int snd_seq_port_info_get_read_use(const snd_seq_port_info_t *info)
1953 assert(info);
1954 return info->read_use;
1959 * \param info port_info container
1964 int snd_seq_port_info_get_write_use(const snd_seq_port_info_t *info)
1966 assert(info);
1967 return info->write_use;
1972 * \param info port_info container
1977 int snd_seq_port_info_get_midi_channels(const snd_seq_port_info_t *info)
1979 assert(info);
1980 return info->midi_channels;
1985 * \param info port_info container
1990 int snd_seq_port_info_get_midi_voices(const snd_seq_port_info_t *info)
1992 assert(info);
1993 return info->midi_voices;
1998 * \param info port_info container
2003 int snd_seq_port_info_get_synth_voices(const snd_seq_port_info_t *info)
2005 assert(info);
2006 return info->synth_voices;
2011 * \param info port_info container
2016 int snd_seq_port_info_get_port_specified(const snd_seq_port_info_t *info)
2018 assert(info);
2019 return (info->flags & SNDRV_SEQ_PORT_FLG_GIVEN_PORT) ? 1 : 0;
2024 * \param info port_info container
2029 int snd_seq_port_info_get_timestamping(const snd_seq_port_info_t *info)
2031 assert(info);
2032 return (info->flags & SNDRV_SEQ_PORT_FLG_TIMESTAMP) ? 1 : 0;
2037 * \param info port_info container
2042 int snd_seq_port_info_get_timestamp_real(const snd_seq_port_info_t *info)
2044 assert(info);
2045 return (info->flags & SNDRV_SEQ_PORT_FLG_TIME_REAL) ? 1 : 0;
2050 * \param info port_info container
2055 int snd_seq_port_info_get_timestamp_queue(const snd_seq_port_info_t *info)
2057 assert(info);
2058 return info->time_queue;
2063 * \param info port_info container
2068 void snd_seq_port_info_set_client(snd_seq_port_info_t *info, int client)
2070 assert(info);
2071 info->addr.client = client;
2076 * \param info port_info container
2081 void snd_seq_port_info_set_port(snd_seq_port_info_t *info, int port)
2083 assert(info);
2084 info->addr.port = port;
2089 * \param info port_info container
2094 void snd_seq_port_info_set_addr(snd_seq_port_info_t *info, const snd_seq_addr_t *addr)
2096 assert(info);
2097 info->addr = *addr;
2102 * \param info port_info container
2107 void snd_seq_port_info_set_name(snd_seq_port_info_t *info, const char *name)
2109 assert(info && name);
2110 strncpy(info->name, name, sizeof(info->name));
2115 * \param info port_info container
2120 void snd_seq_port_info_set_capability(snd_seq_port_info_t *info
2122 assert(info);
2123 info->capability = capability;
2128 * \param info port_info container
2133 void snd_seq_port_info_set_type(snd_seq_port_info_t *info, unsigned int type)
2135 assert(info);
2136 info->type = type;
2141 * \param info port_info container
2146 void snd_seq_port_info_set_midi_channels(snd_seq_port_info_t *info, int channels)
2148 assert(info);
2149 info->midi_channels = channels;
2154 * \param info port_info container
2159 void snd_seq_port_info_set_midi_voices(snd_seq_port_info_t *info, int voices)
2161 assert(info);
2162 info->midi_voices = voices;
2167 * \param info port_info container
2172 void snd_seq_port_info_set_synth_voices(snd_seq_port_info_t *info, int voices)
2174 assert(info);
2175 info->synth_voices = voices;
2180 * \param info port_info container
2185 void snd_seq_port_info_set_port_specified(snd_seq_port_info_t *info, int val)
2187 assert(info);
2189 info->flags |= SNDRV_SEQ_PORT_FLG_GIVEN_PORT;
2191 info->flags &= ~SNDRV_SEQ_PORT_FLG_GIVEN_PORT;
2196 * \param info port_info container
2201 void snd_seq_port_info_set_timestamping(snd_seq_port_info_t *info, int enable)
2203 assert(info);
2205 info->flags |= SNDRV_SEQ_PORT_FLG_TIMESTAMP;
2207 info->flags &= ~SNDRV_SEQ_PORT_FLG_TIMESTAMP;
2212 * \param info port_info container
2217 void snd_seq_port_info_set_timestamp_real(snd_seq_port_info_t *info, int enable)
2219 assert(info);
2221 info->flags |= SNDRV_SEQ_PORT_FLG_TIME_REAL;
2223 info->flags &= ~SNDRV_SEQ_PORT_FLG_TIME_REAL;
2228 * \param info port_info container
2233 void snd_seq_port_info_set_timestamp_queue(snd_seq_port_info_t *info, int queue)
2235 assert(info);
2236 info->time_queue = queue;
2247 * The attributes of created port is specified in \a info argument.
2249 * The client field in \a info argument is overwritten with the current client id.
2317 * \param info pointer information returns
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);
2325 memset(info, 0, sizeof(snd_seq_port_info_t));
2326 info->addr.client = client;
2327 info->addr.port = port;
2328 return seq->ops->get_port_info(seq, info);
2335 * \param info pointer information returns
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);
2350 * \param info port information to be set
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;
2359 info->addr.port = port;
2360 return seq->ops->set_port_info(seq, info);
2366 * \param info query pattern and result
2369 * \a info argument.
2371 * port field of \a info argument.
2375 * \a info and function returns zero.
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);
2440 * \param info port_subscribe container
2444 const snd_seq_addr_t *snd_seq_port_subscribe_get_sender(const snd_seq_port_subscribe_t *info)
2446 assert(info);
2447 return &info->sender;
2452 * \param info port_subscribe container
2456 const snd_seq_addr_t *snd_seq_port_subscribe_get_dest(const snd_seq_port_subscribe_t *info)
2458 assert(info);
2459 return &info->dest;
2464 * \param info port_subscribe container
2469 int snd_seq_port_subscribe_get_queue(const snd_seq_port_subscribe_t *info)
2471 assert(info);
2472 return info->queue;
2477 * \param info port_subscribe container
2482 int snd_seq_port_subscribe_get_exclusive(const snd_seq_port_subscribe_t *info)
2484 assert(info);
2485 return (info->flags & SNDRV_SEQ_PORT_SUBS_EXCLUSIVE) ? 1 : 0;
2490 * \param info port_subscribe container
2495 int snd_seq_port_subscribe_get_time_update(const snd_seq_port_subscribe_t *info)
2497 assert(info);
2498 return (info->flags & SNDRV_SEQ_PORT_SUBS_TIMESTAMP) ? 1 : 0;
2503 * \param info port_subscribe container
2508 int snd_seq_port_subscribe_get_time_real(const snd_seq_port_subscribe_t *info)
2510 assert(info);
2511 return (info->flags & SNDRV_SEQ_PORT_SUBS_TIME_REAL) ? 1 : 0;
2516 * \param info port_subscribe container
2521 void snd_seq_port_subscribe_set_sender(snd_seq_port_subscribe_t *info, const snd_seq_addr_t *addr)
2523 assert(info);
2524 memcpy(&info->sender, addr, sizeof(*addr));
2529 * \param info port_subscribe container
2534 void snd_seq_port_subscribe_set_dest(snd_seq_port_subscribe_t *info, const snd_seq_addr_t *addr)
2536 assert(info);
2537 memcpy(&info->dest, addr, sizeof(*addr));
2542 * \param info port_subscribe container
2547 void snd_seq_port_subscribe_set_queue(snd_seq_port_subscribe_t *info, int q)
2549 assert(info);
2550 info->queue = q;
2555 * \param info port_subscribe container
2560 void snd_seq_port_subscribe_set_exclusive(snd_seq_port_subscribe_t *info, int val)
2562 assert(info);
2564 info->flags |= SNDRV_SEQ_PORT_SUBS_EXCLUSIVE;
2566 info->flags &= ~SNDRV_SEQ_PORT_SUBS_EXCLUSIVE;
2571 * \param info port_subscribe container
2576 void snd_seq_port_subscribe_set_time_update(snd_seq_port_subscribe_t *info, int val)
2578 assert(info);
2580 info->flags |= SNDRV_SEQ_PORT_SUBS_TIMESTAMP;
2582 info->flags &= ~SNDRV_SEQ_PORT_SUBS_TIMESTAMP;
2587 * \param info port_subscribe container
2592 void snd_seq_port_subscribe_set_time_real(snd_seq_port_subscribe_t *info, int val)
2594 assert(info);
2596 info->flags |= SNDRV_SEQ_PORT_SUBS_TIME_REAL;
2598 info->flags &= ~SNDRV_SEQ_PORT_SUBS_TIME_REAL;
2698 * \param info query_subscribe container
2703 int snd_seq_query_subscribe_get_client(const snd_seq_query_subscribe_t *info)
2705 assert(info);
2706 return info->root.client;
2711 * \param info query_subscribe container
2716 int snd_seq_query_subscribe_get_port(const snd_seq_query_subscribe_t *info)
2718 assert(info);
2719 return info->root.port;
2724 * \param info query_subscribe container
2729 const snd_seq_addr_t *snd_seq_query_subscribe_get_root(const snd_seq_query_subscribe_t *info)
2731 assert(info);
2732 return &info->root;
2737 * \param info query_subscribe container
2742 snd_seq_query_subs_type_t snd_seq_query_subscribe_get_type(const snd_seq_query_subscribe_t *info)
2744 assert(info);
2745 return info->type;
2750 * \param info query_subscribe container
2755 int snd_seq_query_subscribe_get_index(const snd_seq_query_subscribe_t *info)
2757 assert(info);
2758 return info->index;
2763 * \param info query_subscribe container
2768 int snd_seq_query_subscribe_get_num_subs(const snd_seq_query_subscribe_t *info)
2770 assert(info);
2771 return info->num_subs;
2776 * \param info query_subscribe container
2781 const snd_seq_addr_t *snd_seq_query_subscribe_get_addr(const snd_seq_query_subscribe_t *info)
2783 assert(info);
2784 return &info->addr;
2789 * \param info query_subscribe container
2794 int snd_seq_query_subscribe_get_queue(const snd_seq_query_subscribe_t *info)
2796 assert(info);
2797 return info->queue;
2802 * \param info query_subscribe container
2807 int snd_seq_query_subscribe_get_exclusive(const snd_seq_query_subscribe_t *info)
2809 assert(info);
2810 return (info->flags & SNDRV_SEQ_PORT_SUBS_EXCLUSIVE) ? 1 : 0;
2815 * \param info query_subscribe container
2820 int snd_seq_query_subscribe_get_time_update(const snd_seq_query_subscribe_t *info)
2822 assert(info);
2823 return (info->flags & SNDRV_SEQ_PORT_SUBS_TIMESTAMP) ? 1 : 0;
2828 * \param info query_subscribe container
2833 int snd_seq_query_subscribe_get_time_real(const snd_seq_query_subscribe_t *info)
2835 assert(info);
2836 return (info->flags & SNDRV_SEQ_PORT_SUBS_TIMESTAMP) ? 1 : 0;
2841 * \param info query_subscribe container
2846 void snd_seq_query_subscribe_set_client(snd_seq_query_subscribe_t *info, int client)
2848 assert(info);
2849 info->root.client = client;
2854 * \param info query_subscribe container
2859 void snd_seq_query_subscribe_set_port(snd_seq_query_subscribe_t *info, int port)
2861 assert(info);
2862 info->root.port = port;
2867 * \param info query_subscribe container
2872 void snd_seq_query_subscribe_set_root(snd_seq_query_subscribe_t *info, const snd_seq_addr_t *addr)
2874 assert(info);
2875 info->root = *addr;
2880 * \param info query_subscribe container
2885 void snd_seq_query_subscribe_set_type(snd_seq_query_subscribe_t *info, snd_seq_query_subs_type_t type)
2887 assert(info);
2888 info->type = type;
2893 * \param info query_subscribe container
2898 void snd_seq_query_subscribe_set_index(snd_seq_query_subscribe_t *info, int index)
2900 assert(info);
2901 info->index = index;
2982 * \param info queue_info container
2987 int snd_seq_queue_info_get_queue(const snd_seq_queue_info_t *info)
2989 assert(info);
2990 return info->queue;
2995 * \param info queue_info container
3000 const char *snd_seq_queue_info_get_name(const snd_seq_queue_info_t *info)
3002 assert(info);
3003 return info->name;
3008 * \param info queue_info container
3013 int snd_seq_queue_info_get_owner(const snd_seq_queue_info_t *info)
3015 assert(info);
3016 return info->owner;
3021 * \param info queue_info container
3026 int snd_seq_queue_info_get_locked(const snd_seq_queue_info_t *info)
3028 assert(info);
3029 return info->locked;
3034 * \param info queue_info container
3039 unsigned int snd_seq_queue_info_get_flags(const snd_seq_queue_info_t *info)
3041 assert(info);
3042 return info->flags;
3047 * \param info queue_info container
3052 void snd_seq_queue_info_set_name(snd_seq_queue_info_t *info, const char *name)
3054 assert(info && name);
3055 strncpy(info->name, name, sizeof(info->name));
3060 * \param info queue_info container
3065 void snd_seq_queue_info_set_owner(snd_seq_queue_info_t *info, int owner)
3067 assert(info);
3068 info->owner = owner;
3073 * \param info queue_info container
3078 void snd_seq_queue_info_set_locked(snd_seq_queue_info_t *info, int locked)
3080 assert(info);
3081 info->locked = locked;
3086 * \param info queue_info container
3091 void snd_seq_queue_info_set_flags(snd_seq_queue_info_t *info, unsigned int flags)
3093 assert(info);
3094 info->flags = flags;
3101 * \param info queue information to initialize
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);
3114 return info->queue;
3127 snd_seq_queue_info_t info;
3128 memset(&info, 0, sizeof(info));
3129 info.locked = 1;
3131 strncpy(info.name, name, sizeof(info.name) - 1);
3132 return snd_seq_create_queue(seq, &info);
3158 snd_seq_queue_info_t info;
3160 memset(&info, 0, sizeof(info));
3161 info.queue = q;
3162 return seq->ops->delete_queue(seq, &info);
3169 * \param info information returned
3174 int snd_seq_get_queue_info(snd_seq_t *seq, int q, snd_seq_queue_info_t *info)
3176 assert(seq && info);
3177 info->queue = q;
3178 return seq->ops->get_queue_info(seq, info);
3185 * \param info information changed
3190 int snd_seq_set_queue_info(snd_seq_t *seq, int q, snd_seq_queue_info_t *info)
3192 assert(seq && info);
3193 info->queue = q;
3194 return seq->ops->set_queue_info(seq, info);
3210 snd_seq_queue_info_t info;
3212 strncpy(info.name, name, sizeof(info.name));
3213 err = seq->ops->get_named_queue(seq, &info);
3216 return info.queue;
3230 struct sndrv_seq_queue_client info;
3233 memset(&info, 0, sizeof(info));
3234 info.queue = q;
3235 info.client = seq->client;
3236 if ((err = seq->ops->get_queue_client(seq, &info)) < 0)
3238 return info.used;
3252 struct sndrv_seq_queue_client info;
3254 memset(&info, 0, sizeof(info));
3255 info.queue = q;
3256 info.client = seq->client;
3257 info.used = used ? 1 : 0;
3258 return seq->ops->set_queue_client(seq, &info);
3308 * \param info queue_status container
3313 int snd_seq_queue_status_get_queue(const snd_seq_queue_status_t *info)
3315 assert(info);
3316 return info->queue;
3321 * \param info queue_status container
3326 int snd_seq_queue_status_get_events(const snd_seq_queue_status_t *info)
3328 assert(info);
3329 return info->events;
3334 * \param info queue_status container
3339 info)
3341 assert(info);
3342 return info->tick;
3347 * \param info queue_status container
3351 const snd_seq_real_time_t *snd_seq_queue_status_get_real_time(const snd_seq_queue_status_t *info)
3353 assert(info);
3354 return &info->time;
3359 * \param info queue_status container
3364 unsigned int snd_seq_queue_status_get_status(const snd_seq_queue_status_t *info)
3366 assert(info);
3367 return info->running;
3435 * \param info queue_status container
3440 int snd_seq_queue_tempo_get_queue(const snd_seq_queue_tempo_t *info)
3442 assert(info);
3443 return info->queue;
3448 * \param info queue_status container
3453 unsigned int snd_seq_queue_tempo_get_tempo(const snd_seq_queue_tempo_t *info)
3455 assert(info);
3456 return info->tempo;
3461 * \param info queue_status container
3466 int snd_seq_queue_tempo_get_ppq(const snd_seq_queue_tempo_t *info)
3468 assert(info);
3469 return info->ppq;
3474 * \param info queue_status container
3479 unsigned int snd_seq_queue_tempo_get_skew(const snd_seq_queue_tempo_t *info)
3481 assert(info);
3482 return info->skew_value;
3487 * \param info queue_status container
3492 unsigned int snd_seq_queue_tempo_get_skew_base(const snd_seq_queue_tempo_t *info)
3494 assert(info);
3495 return info->skew_base;
3500 * \param info queue_status container
3505 void snd_seq_queue_tempo_set_tempo(snd_seq_queue_tempo_t *info, unsigned int tempo)
3507 assert(info);
3508 info->tempo = tempo;
3513 * \param info queue_status container
3518 void snd_seq_queue_tempo_set_ppq(snd_seq_queue_tempo_t *info, int ppq)
3520 assert(info);
3521 info->ppq = ppq;
3526 * \param info queue_status container
3534 void snd_seq_queue_tempo_set_skew(snd_seq_queue_tempo_t *info, unsigned int skew)
3536 assert(info);
3537 info->skew_value = skew;
3542 * \param info queue_status container
3547 void snd_seq_queue_tempo_set_skew_base(snd_seq_queue_tempo_t *info, unsigned int base)
3549 assert(info);
3550 info->skew_base = base;
3635 * \param info queue_timer container
3640 int snd_seq_queue_timer_get_queue(const snd_seq_queue_timer_t *info)
3642 assert(info);
3643 return info->queue;
3648 * \param info queue_timer container
3653 snd_seq_queue_timer_type_t snd_seq_queue_timer_get_type(const snd_seq_queue_timer_t *info)
3655 assert(info);
3656 return (snd_seq_queue_timer_type_t)info->type;
3661 * \param info queue_timer container
3666 const snd_timer_id_t *snd_seq_queue_timer_get_id(const snd_seq_queue_timer_t *info)
3668 assert(info);
3669 return &info->u.alsa.id;
3674 * \param info queue_timer container
3679 unsigned int snd_seq_queue_timer_get_resolution(const snd_seq_queue_timer_t *info)
3681 assert(info);
3682 return info->u.alsa.resolution;
3687 * \param info queue_timer container
3692 void snd_seq_queue_timer_set_type(snd_seq_queue_timer_t *info, snd_seq_queue_timer_type_t type)
3694 assert(info);
3695 info->type = (int)type;
3700 * \param info queue_timer container
3705 void snd_seq_queue_timer_set_id(snd_seq_queue_timer_t *info, const snd_timer_id_t *id)
3707 assert(info && id);
3708 info->u.alsa.id = *id;
3713 * \param info queue_timer container
3718 void snd_seq_queue_timer_set_resolution(snd_seq_queue_timer_t *info, unsigned int resolution)
3720 assert(info);
3721 info->u.alsa.resolution = resolution;
4258 * \param info remove_events container
4263 unsigned int snd_seq_remove_events_get_condition(const snd_seq_remove_events_t *info)
4265 assert(info);
4266 return info->remove_mode;
4271 * \param info remove_events container
4276 int snd_seq_remove_events_get_queue(const snd_seq_remove_events_t *info)
4278 assert(info);
4279 return info->queue;
4284 * \param info remove_events container
4289 const snd_seq_timestamp_t *snd_seq_remove_events_get_time(const snd_seq_remove_events_t *info)
4291 assert(info);
4292 return &info->time;
4297 * \param info remove_events container
4302 const snd_seq_addr_t *snd_seq_remove_events_get_dest(const snd_seq_remove_events_t *info)
4304 assert(info);
4305 return &info->dest;
4310 * \param info remove_events container
4315 int snd_seq_remove_events_get_channel(const snd_seq_remove_events_t *info)
4317 assert(info);
4318 return info->channel;
4323 * \param info remove_events container
4328 int snd_seq_remove_events_get_event_type(const snd_seq_remove_events_t *info)
4330 assert(info);
4331 return info->type;
4336 * \param info remove_events container
4341 int snd_seq_remove_events_get_tag(const snd_seq_remove_events_t *info)
4343 assert(info);
4344 return info->tag;
4349 * \param info remove_events container
4354 void snd_seq_remove_events_set_condition(snd_seq_remove_events_t *info, unsigned int flags)
4356 assert(info);
4357 info->remove_mode = flags;
4362 * \param info remove_events container
4367 void snd_seq_remove_events_set_queue(snd_seq_remove_events_t *info, int queue)
4369 assert(info);
4370 info->queue = queue;
4375 * \param info remove_events container
4380 void snd_seq_remove_events_set_time(snd_seq_remove_events_t *info, const snd_seq_timestamp_t *time)
4382 assert(info);
4383 info->time = *time;
4388 * \param info remove_events container
4393 void snd_seq_remove_events_set_dest(snd_seq_remove_events_t *info, const snd_seq_addr_t *addr)
4395 assert(info);
4396 info->dest = *addr;
4401 * \param info remove_events container
4406 void snd_seq_remove_events_set_channel(snd_seq_remove_events_t *info, int channel)
4408 assert(info);
4409 info->channel = channel;
4414 * \param info remove_events container
4419 void snd_seq_remove_events_set_event_type(snd_seq_remove_events_t *info, int type)
4421 assert(info);
4422 info->type = type;
4427 * \param info remove_events container
4432 void snd_seq_remove_events_set_tag(snd_seq_remove_events_t *info, int tag)
4434 assert(info);
4435 info->tag = tag;
4458 static int remove_match(snd_seq_remove_events_t *info, snd_seq_event_t *ev)
4462 if (info->remove_mode & SNDRV_SEQ_REMOVE_DEST) {
4463 if (ev->dest.client != info->dest.client ||
4464 ev->dest.port != info->dest.port)
4467 if (info->remove_mode & SNDRV_SEQ_REMOVE_DEST_CHANNEL) {
4471 if (ev->data.note.channel != info->channel)
4474 if (info->remove_mode & SNDRV_SEQ_REMOVE_TIME_AFTER) {
4475 if (info->remove_mode & SNDRV_SEQ_REMOVE_TIME_TICK)
4476 res = snd_seq_compare_tick_time(&ev->time.tick, &info->time.tick);
4478 res = snd_seq_compare_real_time(&ev->time.time, &info->time.time);
4482 if (info->remove_mode & SNDRV_SEQ_REMOVE_TIME_BEFORE) {
4483 if (info->remove_mode & SNDRV_SEQ_REMOVE_TIME_TICK)
4484 res = snd_seq_compare_tick_time(&ev->time.tick, &info->time.tick);
4486 res = snd_seq_compare_real_time(&ev->time.time, &info->time.time);
4490 if (info->remove_mode & SNDRV_SEQ_REMOVE_EVENT_TYPE) {
4491 if (ev->type != info->type)
4494 if (info->remove_mode & SNDRV_SEQ_REMOVE_IGNORE_OFF) {
4504 if (info->remove_mode & SNDRV_SEQ_REMOVE_TAG_MATCH) {
4505 if (info->tag != ev->tag)
4618 * \param info client_pool container
4621 int snd_seq_client_pool_get_client(const snd_seq_client_pool_t *info)
4623 assert(info);
4624 return info->client;
4629 * \param info client_pool container
4632 size_t snd_seq_client_pool_get_output_pool(const snd_seq_client_pool_t *info)
4634 assert(info);
4635 return info->output_pool;
4640 * \param info client_pool container
4643 size_t snd_seq_client_pool_get_input_pool(const snd_seq_client_pool_t *info)
4645 assert(info);
4646 return info->input_pool;
4651 * \param info client_pool container
4654 size_t snd_seq_client_pool_get_output_room(const snd_seq_client_pool_t *info)
4656 assert(info);
4657 return info->output_room;
4662 * \param info client_pool container
4665 size_t snd_seq_client_pool_get_output_free(const snd_seq_client_pool_t *info)
4667 assert(info);
4668 return info->output_free;
4673 info client_pool container
4676 size_t snd_seq_client_pool_get_input_free(const snd_seq_client_pool_t *info)
4678 assert(info);
4679 return info->input_free;
4684 * \param info client_pool container
4687 void snd_seq_client_pool_set_output_pool(snd_seq_client_pool_t *info, size_t size)
4689 assert(info);
4690 info->output_pool = size;
4695 * \param info client_pool container
4698 void snd_seq_client_pool_set_input_pool(snd_seq_client_pool_t *info, size_t size)
4700 assert(info);
4701 info->input_pool = size;
4706 * \param info client_pool container
4709 void snd_seq_client_pool_set_output_room(snd_seq_client_pool_t *info, size_t size)
4711 assert(info);
4712 info->output_room = size;
4719 * \param info information to be stored
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);
4731 * \param info information to update
4734 * The client field in \a info is replaced automatically with the current id.
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);
