Lines Matching refs:info
1336 * \param info #snd_seq_system_info_t container
1341 int snd_seq_system_info_get_queues(const snd_seq_system_info_t *info)
1343 assert(info);
1344 return info->queues;
1349 * \param info #snd_seq_system_info_t container
1354 int snd_seq_system_info_get_clients(const snd_seq_system_info_t *info)
1356 assert(info);
1357 return info->clients;
1362 * \param info #snd_seq_system_info_t container
1367 int snd_seq_system_info_get_ports(const snd_seq_system_info_t *info)
1369 assert(info);
1370 return info->ports;
1375 * \param info #snd_seq_system_info_t container
1380 int snd_seq_system_info_get_channels(const snd_seq_system_info_t *info)
1382 assert(info);
1383 return info->channels;
1388 * \param info #snd_seq_system_info_t container
1393 int snd_seq_system_info_get_cur_clients(const snd_seq_system_info_t *info)
1395 assert(info);
1396 return info->cur_clients;
1401 * \param info #snd_seq_system_info_t container
1406 int snd_seq_system_info_get_cur_queues(const snd_seq_system_info_t *info)
1408 assert(info);
1409 return info->cur_queues;
1415 * \param info the pointer to be stored
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);
1477 * \param info client_info container
1482 int snd_seq_client_info_get_client(const snd_seq_client_info_t *info)
1484 assert(info);
1485 return info->client;
1490 * \param info client_info container
1498 snd_seq_client_type_t snd_seq_client_info_get_type(const snd_seq_client_info_t *info)
1500 assert(info);
1501 return info->type;
1506 * \param info client_info container
1511 const char *snd_seq_client_info_get_name(snd_seq_client_info_t *info)
1513 assert(info);
1514 return info->name;
1519 * \param info client_info container
1524 int snd_seq_client_info_get_broadcast_filter(const snd_seq_client_info_t *info)
1526 assert(info);
1527 return (info->filter & SNDRV_SEQ_FILTER_BROADCAST) ? 1 : 0;
1532 * \param info client_info container
1537 int snd_seq_client_info_get_error_bounce(const snd_seq_client_info_t *info)
1539 assert(info);
1540 return (info->filter & SNDRV_SEQ_FILTER_BOUNCE) ? 1 : 0;
1545 * \param info client_info container
1568 int snd_seq_client_info_get_card(const snd_seq_client_info_t *info)
1570 assert(info);
1571 return info->card;
1576 * \param info client_info container
1603 int snd_seq_client_info_get_pid(const snd_seq_client_info_t *info)
1605 assert(info);
1606 return info->pid;
1611 * \param info client_info container
1622 const unsigned char *snd_seq_client_info_get_event_filter(const snd_seq_client_info_t *info)
1624 assert(info);
1625 if (info->filter & SNDRV_SEQ_FILTER_USE_EVENT)
1626 return info->event_filter;
1633 * \param info client_info container
1644 void snd_seq_client_info_event_filter_clear(snd_seq_client_info_t *info)
1646 assert(info);
1647 info->filter &= ~SNDRV_SEQ_FILTER_USE_EVENT;
1648 memset(info->event_filter, 0, sizeof(info->event_filter));
1653 * \param info client_info container
1665 void snd_seq_client_info_event_filter_add(snd_seq_client_info_t *info, int event_type)
1667 assert(info);
1668 info->filter |= SNDRV_SEQ_FILTER_USE_EVENT;
1669 snd_seq_set_bit(event_type, info->event_filter);
1674 * \param info client_info container
1686 void snd_seq_client_info_event_filter_del(snd_seq_client_info_t *info, int event_type)
1688 assert(info);
1689 snd_seq_unset_bit(event_type, info->event_filter);
1694 * \param info client_info container
1706 int snd_seq_client_info_event_filter_check(snd_seq_client_info_t *info, int event_type)
1708 assert(info);
1709 return snd_seq_get_bit(event_type, info->event_filter);
1714 * \param info client_info container
1719 int snd_seq_client_info_get_num_ports(const snd_seq_client_info_t *info)
1721 assert(info);
1722 return info->num_ports;
1727 * \param info client_info container
1732 int snd_seq_client_info_get_event_lost(const snd_seq_client_info_t *info)
1734 assert(info);
1735 return info->event_lost;
1740 * \param info client_info container
1745 int snd_seq_client_info_get_midi_version(const snd_seq_client_info_t *info)
1747 assert(info);
1748 return info->midi_version;
1753 * \param info client_info container
1759 int snd_seq_client_info_get_ump_group_enabled(const snd_seq_client_info_t *info,
1762 assert(info);
1763 return !(info->group_filter & (1U << group));
1772 * \param info client_info container
1777 int snd_seq_client_info_get_ump_groupless_enabled(const snd_seq_client_info_t *info)
1779 assert(info);
1780 return !(info->group_filter & UMP_GROUPLESS_FILTER);
1785 * \param info client_info container
1790 int snd_seq_client_info_get_ump_conversion(const snd_seq_client_info_t *info)
1792 assert(info);
1793 return info->midi_version;
1798 * \param info client_info container
1803 void snd_seq_client_info_set_client(snd_seq_client_info_t *info, int client)
1805 assert(info);
1806 info->client = client;
1811 * \param info client_info container
1817 void snd_seq_client_info_set_name(snd_seq_client_info_t *info, const char *name)
1819 assert(info && name);
1820 snd_strlcpy(info->name, name, sizeof(info->name));
1825 * \param info client_info container
1830 void snd_seq_client_info_set_broadcast_filter(snd_seq_client_info_t *info, int val)
1832 assert(info);
1834 info->filter |= SNDRV_SEQ_FILTER_BROADCAST;
1836 info->filter &= ~SNDRV_SEQ_FILTER_BROADCAST;
1841 * \param info client_info container
1846 void snd_seq_client_info_set_midi_version(snd_seq_client_info_t *info, int midi_version)
1848 assert(info);
1849 info->midi_version = midi_version;
1854 * \param info client_info container
1860 void snd_seq_client_info_set_ump_group_enabled(snd_seq_client_info_t *info,
1863 assert(info);
1865 info->group_filter &= ~(1U << group);
1867 info->group_filter |= (1U << group);
1872 * \param info client_info container
1877 void snd_seq_client_info_set_ump_groupless_enabled(snd_seq_client_info_t *info,
1880 assert(info);
1882 info->group_filter &= ~UMP_GROUPLESS_FILTER;
1884 info->group_filter |= UMP_GROUPLESS_FILTER;
1889 * \param info client_info container
1894 void snd_seq_client_info_set_ump_conversion(snd_seq_client_info_t *info,
1897 assert(info);
1899 info->filter &= ~SNDRV_SEQ_FILTER_NO_CONVERT;
1901 info->filter |= SNDRV_SEQ_FILTER_NO_CONVERT;
1906 * \param info client_info container
1911 void snd_seq_client_info_set_error_bounce(snd_seq_client_info_t *info, int val)
1913 assert(info);
1915 info->filter |= SNDRV_SEQ_FILTER_BOUNCE;
1917 info->filter &= ~SNDRV_SEQ_FILTER_BOUNCE;
1922 * \param info client_info container
1933 void snd_seq_client_info_set_event_filter(snd_seq_client_info_t *info, unsigned char *filter)
1935 assert(info);
1937 info->filter &= ~SNDRV_SEQ_FILTER_USE_EVENT;
1939 info->filter |= SNDRV_SEQ_FILTER_USE_EVENT;
1940 memcpy(info->event_filter, filter, sizeof(info->event_filter));
1949 * \param info the pointer to be stored
1953 * info argument.
1954 * The obtained information is written on info parameter.
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);
1961 memset(info, 0, sizeof(snd_seq_client_info_t));
1962 info->client = client;
1963 return seq->ops->get_client_info(seq, info);
1969 * \param info the pointer to be stored
1972 * Obtains the information of the current client stored on info.
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);
1986 * \param info the client info data to set
1989 * Obtains the information of the current client stored on info.
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;
1998 info->type = USER_CLIENT;
1999 return seq->ops->set_client_info(seq, info);
2005 * \param info query pattern and result
2009 * client field in info.
2010 * If a client is found, its attributes are stored in info,
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);
2026 * \param info the pointer to store snd_ump_endpoint_info_t data
2029 int snd_seq_get_ump_endpoint_info(snd_seq_t *seq, int client, void *info)
2031 assert(seq && info);
2034 info);
2042 * \param info the pointer to store snd_ump_block_info_t data
2045 int snd_seq_get_ump_block_info(snd_seq_t *seq, int client, int blk, void *info)
2047 assert(seq && info);
2050 info);
2056 * \param info the pointer to send snd_ump_endpoint_info_t data
2059 int snd_seq_set_ump_endpoint_info(snd_seq_t *seq, const void *info)
2061 assert(seq && info);
2064 info);
2071 * \param info the pointer to send snd_ump_block_info_t data
2074 int snd_seq_set_ump_block_info(snd_seq_t *seq, int blk, const void *info)
2076 assert(seq && info);
2079 info);
2135 * \param info port_info container
2140 int snd_seq_port_info_get_client(const snd_seq_port_info_t *info)
2142 assert(info);
2143 return info->addr.client;
2148 * \param info port_info container
2153 int snd_seq_port_info_get_port(const snd_seq_port_info_t *info)
2155 assert(info);
2156 return info->addr.port;
2161 * \param info port_info container
2166 const snd_seq_addr_t *snd_seq_port_info_get_addr(const snd_seq_port_info_t *info)
2168 assert(info);
2169 return (const snd_seq_addr_t *) &info->addr;
2174 * \param info port_info container
2179 const char *snd_seq_port_info_get_name(const snd_seq_port_info_t *info)
2181 assert(info);
2182 return info->name;
2187 * \param info port_info container
2192 unsigned int snd_seq_port_info_get_capability(const snd_seq_port_info_t *info)
2194 assert(info);
2195 return info->capability;
2200 * \param info port_info container
2205 unsigned int snd_seq_port_info_get_type(const snd_seq_port_info_t *info)
2207 assert(info);
2208 return info->type;
2213 * \param info port_info container
2218 int snd_seq_port_info_get_read_use(const snd_seq_port_info_t *info)
2220 assert(info);
2221 return info->read_use;
2226 * \param info port_info container
2231 int snd_seq_port_info_get_write_use(const snd_seq_port_info_t *info)
2233 assert(info);
2234 return info->write_use;
2239 * \param info port_info container
2244 int snd_seq_port_info_get_midi_channels(const snd_seq_port_info_t *info)
2246 assert(info);
2247 return info->midi_channels;
2252 * \param info port_info container
2257 int snd_seq_port_info_get_midi_voices(const snd_seq_port_info_t *info)
2259 assert(info);
2260 return info->midi_voices;
2265 * \param info port_info container
2270 int snd_seq_port_info_get_synth_voices(const snd_seq_port_info_t *info)
2272 assert(info);
2273 return info->synth_voices;
2278 * \param info port_info container
2283 int snd_seq_port_info_get_port_specified(const snd_seq_port_info_t *info)
2285 assert(info);
2286 return (info->flags & SNDRV_SEQ_PORT_FLG_GIVEN_PORT) ? 1 : 0;
2291 * \param info port_info container
2296 int snd_seq_port_info_get_timestamping(const snd_seq_port_info_t *info)
2298 assert(info);
2299 return (info->flags & SNDRV_SEQ_PORT_FLG_TIMESTAMP) ? 1 : 0;
2304 * \param info port_info container
2309 int snd_seq_port_info_get_timestamp_real(const snd_seq_port_info_t *info)
2311 assert(info);
2312 return (info->flags & SNDRV_SEQ_PORT_FLG_TIME_REAL) ? 1 : 0;
2317 * \param info port_info container
2322 int snd_seq_port_info_get_timestamp_queue(const snd_seq_port_info_t *info)
2324 assert(info);
2325 return info->time_queue;
2330 * \param info port_info container
2335 int snd_seq_port_info_get_direction(const snd_seq_port_info_t *info)
2337 assert(info);
2338 return info->direction;
2343 * \param info port_info container
2348 int snd_seq_port_info_get_ump_group(const snd_seq_port_info_t *info)
2350 assert(info);
2351 return info->ump_group;
2356 * \param info port_info container
2361 void snd_seq_port_info_set_client(snd_seq_port_info_t *info, int client)
2363 assert(info);
2364 info->addr.client = client;
2369 * \param info port_info container
2374 void snd_seq_port_info_set_port(snd_seq_port_info_t *info, int port)
2376 assert(info);
2377 info->addr.port = port;
2382 * \param info port_info container
2387 void snd_seq_port_info_set_addr(snd_seq_port_info_t *info, const snd_seq_addr_t *addr)
2389 assert(info);
2390 info->addr = *(const struct sndrv_seq_addr *)addr;
2395 * \param info port_info container
2400 void snd_seq_port_info_set_name(snd_seq_port_info_t *info, const char *name)
2402 assert(info && name);
2403 snd_strlcpy(info->name, name, sizeof(info->name));
2408 * \param info port_info container
2413 void snd_seq_port_info_set_capability(snd_seq_port_info_t *info, unsigned int capability)
2415 assert(info);
2416 info->capability = capability;
2421 * \param info port_info container
2426 void snd_seq_port_info_set_type(snd_seq_port_info_t *info, unsigned int type)
2428 assert(info);
2429 info->type = type;
2434 * \param info port_info container
2439 void snd_seq_port_info_set_midi_channels(snd_seq_port_info_t *info, int channels)
2441 assert(info);
2442 info->midi_channels = channels;
2447 * \param info port_info container
2452 void snd_seq_port_info_set_midi_voices(snd_seq_port_info_t *info, int voices)
2454 assert(info);
2455 info->midi_voices = voices;
2460 * \param info port_info container
2465 void snd_seq_port_info_set_synth_voices(snd_seq_port_info_t *info, int voices)
2467 assert(info);
2468 info->synth_voices = voices;
2473 * \param info port_info container
2478 void snd_seq_port_info_set_port_specified(snd_seq_port_info_t *info, int val)
2480 assert(info);
2482 info->flags |= SNDRV_SEQ_PORT_FLG_GIVEN_PORT;
2484 info->flags &= ~SNDRV_SEQ_PORT_FLG_GIVEN_PORT;
2489 * \param info port_info container
2494 void snd_seq_port_info_set_timestamping(snd_seq_port_info_t *info, int enable)
2496 assert(info);
2498 info->flags |= SNDRV_SEQ_PORT_FLG_TIMESTAMP;
2500 info->flags &= ~SNDRV_SEQ_PORT_FLG_TIMESTAMP;
2505 * \param info port_info container
2510 void snd_seq_port_info_set_timestamp_real(snd_seq_port_info_t *info, int enable)
2512 assert(info);
2514 info->flags |= SNDRV_SEQ_PORT_FLG_TIME_REAL;
2516 info->flags &= ~SNDRV_SEQ_PORT_FLG_TIME_REAL;
2521 * \param info port_info container
2526 void snd_seq_port_info_set_timestamp_queue(snd_seq_port_info_t *info, int queue)
2528 assert(info);
2529 info->time_queue = queue;
2534 * \param info port_info container
2539 void snd_seq_port_info_set_direction(snd_seq_port_info_t *info, int direction)
2541 assert(info);
2542 info->direction = direction;
2547 * \param info port_info container
2552 void snd_seq_port_info_set_ump_group(snd_seq_port_info_t *info, int ump_group)
2554 assert(info);
2555 info->ump_group = ump_group;
2565 * The attributes of created port is specified in \a info argument.
2567 * The client field in \a info argument is overwritten with the current client id.
2635 * \param info pointer information returns
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);
2643 memset(info, 0, sizeof(snd_seq_port_info_t));
2644 info->addr.client = client;
2645 info->addr.port = port;
2646 return seq->ops->get_port_info(seq, info);
2653 * \param info pointer information returns
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);
2668 * \param info port information to be set
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;
2677 info->addr.port = port;
2678 return seq->ops->set_port_info(seq, info);
2684 * \param info query pattern and result
2687 * \a info argument.
2689 * port field of \a info argument.
2693 * \a info and function returns zero.
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);
2758 * \param info port_subscribe container
2762 const snd_seq_addr_t *snd_seq_port_subscribe_get_sender(const snd_seq_port_subscribe_t *info)
2764 assert(info);
2765 return (const snd_seq_addr_t *)&info->sender;
2770 * \param info port_subscribe container
2774 const snd_seq_addr_t *snd_seq_port_subscribe_get_dest(const snd_seq_port_subscribe_t *info)
2776 assert(info);
2777 return (const snd_seq_addr_t *)&info->dest;
2782 * \param info port_subscribe container
2787 int snd_seq_port_subscribe_get_queue(const snd_seq_port_subscribe_t *info)
2789 assert(info);
2790 return info->queue;
2795 * \param info port_subscribe container
2800 int snd_seq_port_subscribe_get_exclusive(const snd_seq_port_subscribe_t *info)
2802 assert(info);
2803 return (info->flags & SNDRV_SEQ_PORT_SUBS_EXCLUSIVE) ? 1 : 0;
2808 * \param info port_subscribe container
2813 int snd_seq_port_subscribe_get_time_update(const snd_seq_port_subscribe_t *info)
2815 assert(info);
2816 return (info->flags & SNDRV_SEQ_PORT_SUBS_TIMESTAMP) ? 1 : 0;
2821 * \param info port_subscribe container
2826 int snd_seq_port_subscribe_get_time_real(const snd_seq_port_subscribe_t *info)
2828 assert(info);
2829 return (info->flags & SNDRV_SEQ_PORT_SUBS_TIME_REAL) ? 1 : 0;
2834 * \param info port_subscribe container
2839 void snd_seq_port_subscribe_set_sender(snd_seq_port_subscribe_t *info, const snd_seq_addr_t *addr)
2841 assert(info);
2842 memcpy(&info->sender, addr, sizeof(*addr));
2847 * \param info port_subscribe container
2852 void snd_seq_port_subscribe_set_dest(snd_seq_port_subscribe_t *info, const snd_seq_addr_t *addr)
2854 assert(info);
2855 memcpy(&info->dest, addr, sizeof(*addr));
2860 * \param info port_subscribe container
2865 void snd_seq_port_subscribe_set_queue(snd_seq_port_subscribe_t *info, int q)
2867 assert(info);
2868 info->queue = q;
2873 * \param info port_subscribe container
2878 void snd_seq_port_subscribe_set_exclusive(snd_seq_port_subscribe_t *info, int val)
2880 assert(info);
2882 info->flags |= SNDRV_SEQ_PORT_SUBS_EXCLUSIVE;
2884 info->flags &= ~SNDRV_SEQ_PORT_SUBS_EXCLUSIVE;
2889 * \param info port_subscribe container
2894 void snd_seq_port_subscribe_set_time_update(snd_seq_port_subscribe_t *info, int val)
2896 assert(info);
2898 info->flags |= SNDRV_SEQ_PORT_SUBS_TIMESTAMP;
2900 info->flags &= ~SNDRV_SEQ_PORT_SUBS_TIMESTAMP;
2905 * \param info port_subscribe container
2910 void snd_seq_port_subscribe_set_time_real(snd_seq_port_subscribe_t *info, int val)
2912 assert(info);
2914 info->flags |= SNDRV_SEQ_PORT_SUBS_TIME_REAL;
2916 info->flags &= ~SNDRV_SEQ_PORT_SUBS_TIME_REAL;
3016 * \param info query_subscribe container
3021 int snd_seq_query_subscribe_get_client(const snd_seq_query_subscribe_t *info)
3023 assert(info);
3024 return info->root.client;
3029 * \param info query_subscribe container
3034 int snd_seq_query_subscribe_get_port(const snd_seq_query_subscribe_t *info)
3036 assert(info);
3037 return info->root.port;
3042 * \param info query_subscribe container
3047 const snd_seq_addr_t *snd_seq_query_subscribe_get_root(const snd_seq_query_subscribe_t *info)
3049 assert(info);
3050 return (const snd_seq_addr_t *)&info->root;
3055 * \param info query_subscribe container
3060 snd_seq_query_subs_type_t snd_seq_query_subscribe_get_type(const snd_seq_query_subscribe_t *info)
3062 assert(info);
3063 return info->type;
3068 * \param info query_subscribe container
3073 int snd_seq_query_subscribe_get_index(const snd_seq_query_subscribe_t *info)
3075 assert(info);
3076 return info->index;
3081 * \param info query_subscribe container
3086 int snd_seq_query_subscribe_get_num_subs(const snd_seq_query_subscribe_t *info)
3088 assert(info);
3089 return info->num_subs;
3094 * \param info query_subscribe container
3099 const snd_seq_addr_t *snd_seq_query_subscribe_get_addr(const snd_seq_query_subscribe_t *info)
3101 assert(info);
3102 return (const snd_seq_addr_t *)&info->addr;
3107 * \param info query_subscribe container
3112 int snd_seq_query_subscribe_get_queue(const snd_seq_query_subscribe_t *info)
3114 assert(info);
3115 return info->queue;
3120 * \param info query_subscribe container
3125 int snd_seq_query_subscribe_get_exclusive(const snd_seq_query_subscribe_t *info)
3127 assert(info);
3128 return (info->flags & SNDRV_SEQ_PORT_SUBS_EXCLUSIVE) ? 1 : 0;
3133 * \param info query_subscribe container
3138 int snd_seq_query_subscribe_get_time_update(const snd_seq_query_subscribe_t *info)
3140 assert(info);
3141 return (info->flags & SNDRV_SEQ_PORT_SUBS_TIMESTAMP) ? 1 : 0;
3146 * \param info query_subscribe container
3151 int snd_seq_query_subscribe_get_time_real(const snd_seq_query_subscribe_t *info)
3153 assert(info);
3154 return (info->flags & SNDRV_SEQ_PORT_SUBS_TIMESTAMP) ? 1 : 0;
3159 * \param info query_subscribe container
3164 void snd_seq_query_subscribe_set_client(snd_seq_query_subscribe_t *info, int client)
3166 assert(info);
3167 info->root.client = client;
3172 * \param info query_subscribe container
3177 void snd_seq_query_subscribe_set_port(snd_seq_query_subscribe_t *info, int port)
3179 assert(info);
3180 info->root.port = port;
3185 * \param info query_subscribe container
3190 void snd_seq_query_subscribe_set_root(snd_seq_query_subscribe_t *info, const snd_seq_addr_t *addr)
3192 assert(info);
3193 info->root = *(const struct snd_seq_addr *)addr;
3198 * \param info query_subscribe container
3203 void snd_seq_query_subscribe_set_type(snd_seq_query_subscribe_t *info, snd_seq_query_subs_type_t type)
3205 assert(info);
3206 info->type = type;
3211 * \param info query_subscribe container
3216 void snd_seq_query_subscribe_set_index(snd_seq_query_subscribe_t *info, int index)
3218 assert(info);
3219 info->index = index;
3300 * \param info queue_info container
3305 int snd_seq_queue_info_get_queue(const snd_seq_queue_info_t *info)
3307 assert(info);
3308 return info->queue;
3313 * \param info queue_info container
3318 const char *snd_seq_queue_info_get_name(const snd_seq_queue_info_t *info)
3320 assert(info);
3321 return info->name;
3326 * \param info queue_info container
3331 int snd_seq_queue_info_get_owner(const snd_seq_queue_info_t *info)
3333 assert(info);
3334 return info->owner;
3339 * \param info queue_info container
3344 int snd_seq_queue_info_get_locked(const snd_seq_queue_info_t *info)
3346 assert(info);
3347 return info->locked;
3352 * \param info queue_info container
3357 unsigned int snd_seq_queue_info_get_flags(const snd_seq_queue_info_t *info)
3359 assert(info);
3360 return info->flags;
3365 * \param info queue_info container
3370 void snd_seq_queue_info_set_name(snd_seq_queue_info_t *info, const char *name)
3372 assert(info && name);
3373 snd_strlcpy(info->name, name, sizeof(info->name));
3378 * \param info queue_info container
3383 void snd_seq_queue_info_set_owner(snd_seq_queue_info_t *info, int owner)
3385 assert(info);
3386 info->owner = owner;
3391 * \param info queue_info container
3396 void snd_seq_queue_info_set_locked(snd_seq_queue_info_t *info, int locked)
3398 assert(info);
3399 info->locked = locked;
3404 * \param info queue_info container
3409 void snd_seq_queue_info_set_flags(snd_seq_queue_info_t *info, unsigned int flags)
3411 assert(info);
3412 info->flags = flags;
3419 * \param info queue information to initialize
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);
3432 return info->queue;
3445 snd_seq_queue_info_t info;
3446 memset(&info, 0, sizeof(info));
3447 info.locked = 1;
3449 snd_strlcpy(info.name, name, sizeof(info.name));
3450 return snd_seq_create_queue(seq, &info);
3476 snd_seq_queue_info_t info;
3478 memset(&info, 0, sizeof(info));
3479 info.queue = q;
3480 return seq->ops->delete_queue(seq, &info);
3487 * \param info information returned
3492 int snd_seq_get_queue_info(snd_seq_t *seq, int q, snd_seq_queue_info_t *info)
3494 assert(seq && info);
3495 info->queue = q;
3496 return seq->ops->get_queue_info(seq, info);
3503 * \param info information changed
3508 int snd_seq_set_queue_info(snd_seq_t *seq, int q, snd_seq_queue_info_t *info)
3510 assert(seq && info);
3511 info->queue = q;
3512 return seq->ops->set_queue_info(seq, info);
3528 snd_seq_queue_info_t info;
3530 snd_strlcpy(info.name, name, sizeof(info.name));
3531 err = seq->ops->get_named_queue(seq, &info);
3534 return info.queue;
3548 struct snd_seq_queue_client info;
3551 memset(&info, 0, sizeof(info));
3552 info.queue = q;
3553 info.client = seq->client;
3554 if ((err = seq->ops->get_queue_client(seq, &info)) < 0)
3556 return info.used;
3570 struct snd_seq_queue_client info;
3572 memset(&info, 0, sizeof(info));
3573 info.queue = q;
3574 info.client = seq->client;
3575 info.used = used ? 1 : 0;
3576 return seq->ops->set_queue_client(seq, &info);
3626 * \param info queue_status container
3631 int snd_seq_queue_status_get_queue(const snd_seq_queue_status_t *info)
3633 assert(info);
3634 return info->queue;
3639 * \param info queue_status container
3644 int snd_seq_queue_status_get_events(const snd_seq_queue_status_t *info)
3646 assert(info);
3647 return info->events;
3652 * \param info queue_status container
3657 snd_seq_tick_time_t snd_seq_queue_status_get_tick_time(const snd_seq_queue_status_t *info)
3659 assert(info);
3660 return info->tick;
3665 * \param info queue_status container
3669 const snd_seq_real_time_t *snd_seq_queue_status_get_real_time(const snd_seq_queue_status_t *info)
3671 assert(info);
3672 return (const snd_seq_real_time_t *)&info->time;
3677 * \param info queue_status container
3682 unsigned int snd_seq_queue_status_get_status(const snd_seq_queue_status_t *info)
3684 assert(info);
3685 return info->running;
3753 * \param info queue_status container
3758 int snd_seq_queue_tempo_get_queue(const snd_seq_queue_tempo_t *info)
3760 assert(info);
3761 return info->queue;
3766 * \param info queue_status container
3771 unsigned int snd_seq_queue_tempo_get_tempo(const snd_seq_queue_tempo_t *info)
3773 assert(info);
3774 return info->tempo;
3779 * \param info queue_status container
3784 int snd_seq_queue_tempo_get_ppq(const snd_seq_queue_tempo_t *info)
3786 assert(info);
3787 return info->ppq;
3792 * \param info queue_status container
3797 unsigned int snd_seq_queue_tempo_get_skew(const snd_seq_queue_tempo_t *info)
3799 assert(info);
3800 return info->skew_value;
3805 * \param info queue_status container
3810 unsigned int snd_seq_queue_tempo_get_skew_base(const snd_seq_queue_tempo_t *info)
3812 assert(info);
3813 return info->skew_base;
3818 * \param info queue_status container
3823 void snd_seq_queue_tempo_set_tempo(snd_seq_queue_tempo_t *info, unsigned int tempo)
3825 assert(info);
3826 info->tempo = tempo;
3831 * \param info queue_status container
3836 void snd_seq_queue_tempo_set_ppq(snd_seq_queue_tempo_t *info, int ppq)
3838 assert(info);
3839 info->ppq = ppq;
3844 * \param info queue_status container
3852 void snd_seq_queue_tempo_set_skew(snd_seq_queue_tempo_t *info, unsigned int skew)
3854 assert(info);
3855 info->skew_value = skew;
3860 * \param info queue_status container
3865 void snd_seq_queue_tempo_set_skew_base(snd_seq_queue_tempo_t *info, unsigned int base)
3867 assert(info);
3868 info->skew_base = base;
3953 * \param info queue_timer container
3958 int snd_seq_queue_timer_get_queue(const snd_seq_queue_timer_t *info)
3960 assert(info);
3961 return info->queue;
3966 * \param info queue_timer container
3971 snd_seq_queue_timer_type_t snd_seq_queue_timer_get_type(const snd_seq_queue_timer_t *info)
3973 assert(info);
3974 return (snd_seq_queue_timer_type_t)info->type;
3979 * \param info queue_timer container
3984 const snd_timer_id_t *snd_seq_queue_timer_get_id(const snd_seq_queue_timer_t *info)
3986 assert(info);
3987 return &info->u.alsa.id;
3992 * \param info queue_timer container
3997 unsigned int snd_seq_queue_timer_get_resolution(const snd_seq_queue_timer_t *info)
3999 assert(info);
4000 return info->u.alsa.resolution;
4005 * \param info queue_timer container
4010 void snd_seq_queue_timer_set_type(snd_seq_queue_timer_t *info, snd_seq_queue_timer_type_t type)
4012 assert(info);
4013 info->type = (int)type;
4018 * \param info queue_timer container
4023 void snd_seq_queue_timer_set_id(snd_seq_queue_timer_t *info, const snd_timer_id_t *id)
4025 assert(info && id);
4026 info->u.alsa.id = *id;
4031 * \param info queue_timer container
4036 void snd_seq_queue_timer_set_resolution(snd_seq_queue_timer_t *info, unsigned int resolution)
4038 assert(info);
4039 info->u.alsa.resolution = resolution;
4702 * \param info remove_events container
4707 unsigned int snd_seq_remove_events_get_condition(const snd_seq_remove_events_t *info)
4709 assert(info);
4710 return info->remove_mode;
4715 * \param info remove_events container
4720 int snd_seq_remove_events_get_queue(const snd_seq_remove_events_t *info)
4722 assert(info);
4723 return info->queue;
4728 * \param info remove_events container
4733 const snd_seq_timestamp_t *snd_seq_remove_events_get_time(const snd_seq_remove_events_t *info)
4735 assert(info);
4736 return (const snd_seq_timestamp_t *)&info->time;
4741 * \param info remove_events container
4746 const snd_seq_addr_t *snd_seq_remove_events_get_dest(const snd_seq_remove_events_t *info)
4748 assert(info);
4749 return (const snd_seq_addr_t *)&info->dest;
4754 * \param info remove_events container
4759 int snd_seq_remove_events_get_channel(const snd_seq_remove_events_t *info)
4761 assert(info);
4762 return info->channel;
4767 * \param info remove_events container
4772 int snd_seq_remove_events_get_event_type(const snd_seq_remove_events_t *info)
4774 assert(info);
4775 return info->type;
4780 * \param info remove_events container
4785 int snd_seq_remove_events_get_tag(const snd_seq_remove_events_t *info)
4787 assert(info);
4788 return info->tag;
4793 * \param info remove_events container
4798 void snd_seq_remove_events_set_condition(snd_seq_remove_events_t *info, unsigned int flags)
4800 assert(info);
4801 info->remove_mode = flags;
4806 * \param info remove_events container
4811 void snd_seq_remove_events_set_queue(snd_seq_remove_events_t *info, int queue)
4813 assert(info);
4814 info->queue = queue;
4819 * \param info remove_events container
4824 void snd_seq_remove_events_set_time(snd_seq_remove_events_t *info, const snd_seq_timestamp_t *time)
4826 assert(info);
4827 info->time = *(const union sndrv_seq_timestamp *)time;
4832 * \param info remove_events container
4837 void snd_seq_remove_events_set_dest(snd_seq_remove_events_t *info, const snd_seq_addr_t *addr)
4839 assert(info);
4840 info->dest = *(const struct sndrv_seq_addr *)addr;
4845 * \param info remove_events container
4850 void snd_seq_remove_events_set_channel(snd_seq_remove_events_t *info, int channel)
4852 assert(info);
4853 info->channel = channel;
4858 * \param info remove_events container
4863 void snd_seq_remove_events_set_event_type(snd_seq_remove_events_t *info, int type)
4865 assert(info);
4866 info->type = type;
4871 * \param info remove_events container
4876 void snd_seq_remove_events_set_tag(snd_seq_remove_events_t *info, int tag)
4878 assert(info);
4879 info->tag = tag;
4902 static int remove_match(snd_seq_remove_events_t *info, snd_seq_event_t *ev)
4906 if (info->remove_mode & SNDRV_SEQ_REMOVE_DEST) {
4907 if (ev->dest.client != info->dest.client ||
4908 ev->dest.port != info->dest.port)
4911 if (info->remove_mode & SNDRV_SEQ_REMOVE_DEST_CHANNEL) {
4915 if (ev->data.note.channel != info->channel)
4918 if (info->remove_mode & SNDRV_SEQ_REMOVE_TIME_AFTER) {
4919 if (info->remove_mode & SNDRV_SEQ_REMOVE_TIME_TICK)
4920 res = snd_seq_compare_tick_time(&ev->time.tick, &info->time.tick);
4922 res = snd_seq_compare_real_time(&ev->time.time, (snd_seq_real_time_t *)&info->time.time);
4926 if (info->remove_mode & SNDRV_SEQ_REMOVE_TIME_BEFORE) {
4927 if (info->remove_mode & SNDRV_SEQ_REMOVE_TIME_TICK)
4928 res = snd_seq_compare_tick_time(&ev->time.tick, &info->time.tick);
4930 res = snd_seq_compare_real_time(&ev->time.time, (snd_seq_real_time_t *)&info->time.time);
4934 if (info->remove_mode & SNDRV_SEQ_REMOVE_EVENT_TYPE) {
4935 if (ev->type != info->type)
4938 if (info->remove_mode & SNDRV_SEQ_REMOVE_IGNORE_OFF) {
4948 if (info->remove_mode & SNDRV_SEQ_REMOVE_TAG_MATCH) {
4949 if (info->tag != ev->tag)
5062 * \param info client_pool container
5065 int snd_seq_client_pool_get_client(const snd_seq_client_pool_t *info)
5067 assert(info);
5068 return info->client;
5073 * \param info client_pool container
5076 size_t snd_seq_client_pool_get_output_pool(const snd_seq_client_pool_t *info)
5078 assert(info);
5079 return info->output_pool;
5084 * \param info client_pool container
5087 size_t snd_seq_client_pool_get_input_pool(const snd_seq_client_pool_t *info)
5089 assert(info);
5090 return info->input_pool;
5095 * \param info client_pool container
5098 size_t snd_seq_client_pool_get_output_room(const snd_seq_client_pool_t *info)
5100 assert(info);
5101 return info->output_room;
5106 * \param info client_pool container
5109 size_t snd_seq_client_pool_get_output_free(const snd_seq_client_pool_t *info)
5111 assert(info);
5112 return info->output_free;
5117 * \param info client_pool container
5120 size_t snd_seq_client_pool_get_input_free(const snd_seq_client_pool_t *info)
5122 assert(info);
5123 return info->input_free;
5128 * \param info client_pool container
5131 void snd_seq_client_pool_set_output_pool(snd_seq_client_pool_t *info, size_t size)
5133 assert(info);
5134 info->output_pool = size;
5139 * \param info client_pool container
5142 void snd_seq_client_pool_set_input_pool(snd_seq_client_pool_t *info, size_t size)
5144 assert(info);
5145 info->input_pool = size;
5150 * \param info client_pool container
5153 void snd_seq_client_pool_set_output_room(snd_seq_client_pool_t *info, size_t size)
5155 assert(info);
5156 info->output_room = size;
5163 * \param info information to be stored
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);
5175 * \param info information to update
5178 * The client field in \a info is replaced automatically with the current id.
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);