Lines Matching refs:ctl
44 giving -1 as card index and "ctl" as interface type. Each returned
203 * \param ctl CTL handle
209 const char *snd_ctl_name(snd_ctl_t *ctl)
211 assert(ctl);
212 return ctl->name;
217 * \param ctl CTL handle
222 snd_ctl_type_t snd_ctl_type(snd_ctl_t *ctl)
224 assert(ctl);
225 return ctl->type;
230 * \param ctl CTL handle
236 int snd_ctl_close(snd_ctl_t *ctl)
239 while (!list_empty(&ctl->async_handlers)) {
240 snd_async_handler_t *h = list_entry(&ctl->async_handlers.next, snd_async_handler_t, hlist);
243 err = ctl->ops->close(ctl);
244 free(ctl->name);
245 snd_dlobj_cache_put(ctl->open_func);
246 free(ctl);
252 * \param ctl CTL handle
256 int snd_ctl_nonblock(snd_ctl_t *ctl, int nonblock)
259 assert(ctl);
260 err = ctl->ops->nonblock(ctl, nonblock);
263 ctl->nonblock = nonblock;
270 snd_ctl_t *ctl;
271 ctl = calloc(1, sizeof(*ctl));
272 if (!ctl)
274 ctl->type = type;
275 ctl->mode = mode;
277 ctl->name = strdup(name);
278 INIT_LIST_HEAD(&ctl->async_handlers);
279 *ctlp = ctl;
286 * \param ctl CTL handle
293 int snd_ctl_async(snd_ctl_t *ctl, int sig, pid_t pid)
295 assert(ctl);
300 return ctl->ops->async(ctl, sig, pid);
306 * \param ctl CTL handle
309 int snd_ctl_poll_descriptors_count(snd_ctl_t *ctl)
311 assert(ctl);
312 if (ctl->ops->poll_descriptors_count)
313 return ctl->ops->poll_descriptors_count(ctl);
314 if (ctl->poll_fd < 0)
321 * \param ctl CTL handle
326 int snd_ctl_poll_descriptors(snd_ctl_t *ctl, struct pollfd *pfds, unsigned int space)
328 assert(ctl && pfds);
329 if (ctl->ops->poll_descriptors)
330 return ctl->ops->poll_descriptors(ctl, pfds, space);
331 if (ctl->poll_fd < 0)
334 pfds->fd = ctl->poll_fd;
343 * \param ctl CTL handle
349 int snd_ctl_poll_descriptors_revents(snd_ctl_t *ctl, struct pollfd *pfds, unsigned int nfds, unsigned short *revents)
351 assert(ctl && pfds && revents);
352 if (ctl->ops->poll_revents)
353 return ctl->ops->poll_revents(ctl, pfds, nfds, revents);
363 * \param ctl CTL handle
367 int snd_ctl_subscribe_events(snd_ctl_t *ctl, int subscribe)
369 assert(ctl);
370 return ctl->ops->subscribe_events(ctl, subscribe);
381 * \param ctl The CTL handle.
385 int snd_ctl_card_info(snd_ctl_t *ctl, snd_ctl_card_info_t *info)
387 assert(ctl && info);
388 return ctl->ops->card_info(ctl, info);
408 * \param ctl CTL handle
412 int snd_ctl_elem_list(snd_ctl_t *ctl, snd_ctl_elem_list_t *list)
414 assert(ctl && list);
416 return ctl->ops->element_list(ctl, list);
421 * \param ctl CTL handle
425 int snd_ctl_elem_info(snd_ctl_t *ctl, snd_ctl_elem_info_t *info)
427 assert(ctl && info && (info->id.name[0] || info->id.numid));
428 return ctl->ops->element_info(ctl, info);
488 int __snd_ctl_add_elem_set(snd_ctl_t *ctl, snd_ctl_elem_info_t *info,
492 if (ctl == NULL || info->id.name[0] == '\0')
504 return ctl->ops->element_add(ctl, info);
511 * \param ctl A handle of backend module for control interface.
551 int snd_ctl_add_integer_elem_set(snd_ctl_t *ctl, snd_ctl_elem_info_t *info,
570 err = __snd_ctl_add_elem_set(ctl, info, element_count, member_count);
583 err = ctl->ops->element_write(ctl, &data);
593 * \param ctl A handle of backend module for control interface.
633 int snd_ctl_add_integer64_elem_set(snd_ctl_t *ctl, snd_ctl_elem_info_t *info,
652 err = __snd_ctl_add_elem_set(ctl, info, element_count, member_count);
665 err = ctl->ops->element_write(ctl, &data);
675 * \param ctl A handle of backend module for control interface.
711 int snd_ctl_add_boolean_elem_set(snd_ctl_t *ctl, snd_ctl_elem_info_t *info,
722 return __snd_ctl_add_elem_set(ctl, info, element_count, member_count);
727 * \param ctl A handle of backend module for control interface.
768 int snd_ctl_add_enumerated_elem_set(snd_ctl_t *ctl, snd_ctl_elem_info_t *info,
802 err = __snd_ctl_add_elem_set(ctl, info, element_count, member_count);
811 * \param ctl A handle of backend module for control interface.
848 int snd_ctl_add_bytes_elem_set(snd_ctl_t *ctl, snd_ctl_elem_info_t *info,
857 return __snd_ctl_add_elem_set(ctl, info, element_count, member_count);
867 int snd_ctl_elem_add_integer(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id,
873 assert(ctl && id && id->name[0]);
877 return snd_ctl_add_integer_elem_set(ctl, &info, 1, member_count,
888 int snd_ctl_elem_add_integer64(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id,
894 assert(ctl && id && id->name[0]);
898 return snd_ctl_add_integer64_elem_set(ctl, &info, 1, member_count,
909 int snd_ctl_elem_add_boolean(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id,
914 assert(ctl && id && id->name[0]);
918 return snd_ctl_add_boolean_elem_set(ctl, &info, 1, member_count);
930 int snd_ctl_elem_add_enumerated(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id,
936 assert(ctl && id && id->name[0] && labels);
940 return snd_ctl_add_enumerated_elem_set(ctl, &info, 1, member_count,
946 * \param[in] ctl A handle of backend module for control interface.
973 int snd_ctl_elem_add_iec958(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id)
977 assert(ctl && id && id->name[0]);
983 return ctl->ops->element_add(ctl, &info);
988 * \param ctl CTL handle
992 int snd_ctl_elem_remove(snd_ctl_t *ctl, snd_ctl_elem_id_t *id)
994 assert(ctl && id && (id->name[0] || id->numid));
995 return ctl->ops->element_remove(ctl, id);
1006 * \param ctl CTL handle.
1013 int snd_ctl_elem_read(snd_ctl_t *ctl, snd_ctl_elem_value_t *data)
1015 assert(ctl && data && (data->id.name[0] || data->id.numid));
1016 return ctl->ops->element_read(ctl, data);
1027 * \param ctl CTL handle.
1034 int snd_ctl_elem_write(snd_ctl_t *ctl, snd_ctl_elem_value_t *data)
1036 assert(ctl && data && (data->id.name[0] || data->id.numid));
1037 return ctl->ops->element_write(ctl, data);
1040 static int snd_ctl_tlv_do(snd_ctl_t *ctl, int op_flag,
1053 err = snd_ctl_elem_info(ctl, info);
1061 err = ctl->ops->element_tlv(ctl, op_flag, id->numid, tlv, tlv_size);
1070 * \param ctl A handle of backend module for control interface.
1083 int snd_ctl_elem_tlv_read(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id,
1087 assert(ctl && id && (id->name[0] || id->numid) && tlv);
1097 err = snd_ctl_tlv_do(ctl, 0, id, tlv, tlv_size);
1105 * \param ctl A handle of backend module for control interface.
1120 int snd_ctl_elem_tlv_write(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id,
1123 assert(ctl && id && (id->name[0] || id->numid) && tlv);
1124 return snd_ctl_tlv_do(ctl, 1, id, (unsigned int *)tlv,
1130 * \param ctl A handle of backend module for control interface.
1145 int snd_ctl_elem_tlv_command(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id,
1148 assert(ctl && id && (id->name[0] || id->numid) && tlv);
1149 return snd_ctl_tlv_do(ctl, -1, id, (unsigned int *)tlv,
1155 * \param ctl CTL handle
1159 int snd_ctl_elem_lock(snd_ctl_t *ctl, snd_ctl_elem_id_t *id)
1161 assert(ctl && id);
1162 return ctl->ops->element_lock(ctl, id);
1167 * \param ctl CTL handle
1171 int snd_ctl_elem_unlock(snd_ctl_t *ctl, snd_ctl_elem_id_t *id)
1173 assert(ctl && id);
1174 return ctl->ops->element_unlock(ctl, id);
1179 * \param ctl CTL handle
1183 int snd_ctl_hwdep_next_device(snd_ctl_t *ctl, int *device)
1185 assert(ctl && device);
1186 return ctl->ops->hwdep_next_device(ctl, device);
1191 * \param ctl CTL handle
1195 int snd_ctl_hwdep_info(snd_ctl_t *ctl, snd_hwdep_info_t * info)
1197 assert(ctl && info);
1198 return ctl->ops->hwdep_info(ctl, info);
1203 * \param ctl CTL handle
1207 int snd_ctl_pcm_next_device(snd_ctl_t *ctl, int * device)
1209 assert(ctl && device);
1210 return ctl->ops->pcm_next_device(ctl, device);
1215 * \param ctl CTL handle
1219 int snd_ctl_pcm_info(snd_ctl_t *ctl, snd_pcm_info_t * info)
1221 assert(ctl && info);
1222 return ctl->ops->pcm_info(ctl, info);
1227 * \param ctl CTL handle
1231 int snd_ctl_pcm_prefer_subdevice(snd_ctl_t *ctl, int subdev)
1233 assert(ctl);
1234 return ctl->ops->pcm_prefer_subdevice(ctl, subdev);
1239 * \param ctl CTL handle
1243 int snd_ctl_rawmidi_next_device(snd_ctl_t *ctl, int * device)
1245 assert(ctl && device);
1246 return ctl->ops->rawmidi_next_device(ctl, device);
1251 * \param ctl CTL handle
1255 int snd_ctl_rawmidi_info(snd_ctl_t *ctl, snd_rawmidi_info_t * info)
1257 assert(ctl && info);
1258 return ctl->ops->rawmidi_info(ctl, info);
1263 * \param ctl CTL handle
1267 int snd_ctl_rawmidi_prefer_subdevice(snd_ctl_t *ctl, int subdev)
1269 assert(ctl);
1270 return ctl->ops->rawmidi_prefer_subdevice(ctl, subdev);
1275 * \param ctl CTL handle
1279 int snd_ctl_ump_next_device(snd_ctl_t *ctl, int *device)
1281 assert(ctl && device);
1282 if (ctl->ops->ump_next_device)
1283 return ctl->ops->ump_next_device(ctl, device);
1289 * \param ctl CTL handle
1293 int snd_ctl_ump_endpoint_info(snd_ctl_t *ctl, snd_ump_endpoint_info_t *info)
1295 assert(ctl && info);
1296 return ctl->ops->ump_endpoint_info(ctl, info);
1301 * \param ctl CTL handle
1305 int snd_ctl_ump_block_info(snd_ctl_t *ctl, snd_ump_block_info_t *info)
1307 assert(ctl && info);
1308 return ctl->ops->ump_block_info(ctl, info);
1313 * \param ctl CTL handle
1317 int snd_ctl_set_power_state(snd_ctl_t *ctl, unsigned int state)
1319 assert(ctl);
1320 if (ctl->ops->set_power_state)
1321 return ctl->ops->set_power_state(ctl, state);
1327 * \param ctl CTL handle
1331 int snd_ctl_get_power_state(snd_ctl_t *ctl, unsigned int *state)
1333 assert(ctl);
1334 if (ctl->ops->get_power_state)
1335 return ctl->ops->get_power_state(ctl, state);
1341 * \param ctl CTL handle
1345 int snd_ctl_read(snd_ctl_t *ctl, snd_ctl_event_t *event)
1347 assert(ctl && event);
1348 return (ctl->ops->read)(ctl, event);
1353 * \param ctl CTL handle
1357 int snd_ctl_wait(snd_ctl_t *ctl, int timeout)
1363 npfds = snd_ctl_poll_descriptors_count(ctl);
1369 err = snd_ctl_poll_descriptors(ctl, pfd, npfds);
1382 err = snd_ctl_poll_descriptors_revents(ctl, pfd, npfds, &revents);
1395 * \param ctl CTL handle
1400 int snd_async_add_ctl_handler(snd_async_handler_t **handler, snd_ctl_t *ctl,
1406 err = snd_async_add_handler(&h, _snd_ctl_async_descriptor(ctl),
1411 h->u.ctl = ctl;
1412 was_empty = list_empty(&ctl->async_handlers);
1413 list_add_tail(&h->hlist, &ctl->async_handlers);
1415 err = snd_ctl_async(ctl, snd_async_handler_get_signo(h), getpid());
1433 return handler->u.ctl;
1568 err = snd_config_search_definition(root, "ctl", name, &ctl_conf);
1864 int _snd_ctl_poll_descriptor(snd_ctl_t *ctl)
1866 assert(ctl);
1867 return ctl->poll_fd;