include/control.h

   1 /****************************************************************************
   2  *                                                                          *
   3  *                              control.h                                   *
   4  *                          Control Interface                               *
   5  *                                                                          *
   6  ****************************************************************************/
   7
   8 typedef struct sndrv_aes_iec958 snd_aes_iec958_t;
   9
  10 /** CTL card info container */
  11 typedef struct _snd_ctl_card_info snd_ctl_card_info_t;
  12
  13 /** CTL element identificator container */
  14 typedef struct _snd_ctl_elem_id snd_ctl_elem_id_t;
  15
  16 /** CTL element identificator list container */
  17 typedef struct _snd_ctl_elem_list snd_ctl_elem_list_t;
  18
  19 /** CTL element info container */
  20 typedef struct _snd_ctl_elem_info snd_ctl_elem_info_t;
  21
  22 /** CTL element value container */
  23 typedef struct _snd_ctl_elem_value snd_ctl_elem_value_t;
  24
  25 /** CTL event container */
  26 typedef struct _snd_ctl_event snd_ctl_event_t;
  27
  28 /** Card type */
  29 typedef enum _snd_card_type {
  30         /** Gravis UltraSound Classic */
  31         SND_CARD_TYPE_GUS_CLASSIC = SNDRV_CARD_TYPE_GUS_CLASSIC,
  32         /** Gravis UltraSound Extreme */
  33         SND_CARD_TYPE_GUS_EXTREME = SNDRV_CARD_TYPE_GUS_EXTREME,
  34         /** Gravis UltraSound ACE */
  35         SND_CARD_TYPE_GUS_ACE = SNDRV_CARD_TYPE_GUS_ACE,
  36         /** Gravis UltraSound Max */
  37         SND_CARD_TYPE_GUS_MAX = SNDRV_CARD_TYPE_GUS_MAX,
  38         /** AMD InterWave */
  39         SND_CARD_TYPE_AMD_INTERWAVE = SNDRV_CARD_TYPE_AMD_INTERWAVE,
  40         /** SoundBlaster v1.0 */
  41         SND_CARD_TYPE_SB_10 = SNDRV_CARD_TYPE_SB_10,
  42         /** SoundBlaster v2.0 */
  43         SND_CARD_TYPE_SB_20 = SNDRV_CARD_TYPE_SB_20,
  44         /** SoundBlaster Pro */
  45         SND_CARD_TYPE_SB_PRO = SNDRV_CARD_TYPE_SB_PRO,
  46         /** SoundBlaster 16 */
  47         SND_CARD_TYPE_SB_16 = SNDRV_CARD_TYPE_SB_16,
  48         /** SoundBlaster AWE */
  49         SND_CARD_TYPE_SB_AWE = SNDRV_CARD_TYPE_SB_AWE,
  50         /** ESS ES1688 */
  51         SND_CARD_TYPE_ESS_ES1688 = SNDRV_CARD_TYPE_ESS_ES1688,
  52         /** Yamaha OPL3 SA2/3 */
  53         SND_CARD_TYPE_OPL3_SA2 = SNDRV_CARD_TYPE_OPL3_SA2,
  54         /** Mozart */
  55         SND_CARD_TYPE_MOZART = SNDRV_CARD_TYPE_MOZART,
  56         /** S3 SonicVibes */
  57         SND_CARD_TYPE_S3_SONICVIBES = SNDRV_CARD_TYPE_S3_SONICVIBES,
  58         /** Ensoniq AudioPCI ES1370 */
  59         SND_CARD_TYPE_ENS1370 = SNDRV_CARD_TYPE_ENS1370,
  60         /** Ensoniq AudioPCI ES1371 / Creative CT5880 */
  61         SND_CARD_TYPE_ENS1371 = SNDRV_CARD_TYPE_ENS1371,
  62         /** Cirrus Logic CS4232 */
  63         SND_CARD_TYPE_CS4232 = SNDRV_CARD_TYPE_CS4232,
  64         /** Cirrus Logic CS4236+ */
  65         SND_CARD_TYPE_CS4236 = SNDRV_CARD_TYPE_CS4236,
  66         /** AMD InterWave + TEA6330T */
  67         SND_CARD_TYPE_AMD_INTERWAVE_STB = SNDRV_CARD_TYPE_AMD_INTERWAVE_STB,
  68         /** ESS ES1938 */
  69         SND_CARD_TYPE_ESS_ES1938 = SNDRV_CARD_TYPE_ESS_ES1938,
  70         /** ESS ES18XX */
  71         SND_CARD_TYPE_ESS_ES18XX = SNDRV_CARD_TYPE_ESS_ES18XX,
  72         /** Cirus Logic CS4231 */
  73         SND_CARD_TYPE_CS4231 = SNDRV_CARD_TYPE_CS4231,
  74         /** Opti92x */
  75         SND_CARD_TYPE_OPTI92X = SNDRV_CARD_TYPE_OPTI92X,
  76         /** Serial MIDI */
  77         SND_CARD_TYPE_SERIAL = SNDRV_CARD_TYPE_SERIAL,
  78         /** Analog Devices AD1848 */
  79         SND_CARD_TYPE_AD1848 = SNDRV_CARD_TYPE_AD1848,
  80         /** Trident 4D-Wave DX */
  81         SND_CARD_TYPE_TRID4DWAVEDX = SNDRV_CARD_TYPE_TRID4DWAVEDX,
  82         /** Trident 4D-Wave NX */
  83         SND_CARD_TYPE_TRID4DWAVENX = SNDRV_CARD_TYPE_TRID4DWAVENX,
  84         /** Sound Galaxy */
  85         SND_CARD_TYPE_SGALAXY = SNDRV_CARD_TYPE_SGALAXY,
  86         /** Cirrus Logic CS46xx */
  87         SND_CARD_TYPE_CS46XX = SNDRV_CARD_TYPE_CS46XX,
  88         /** WaveFront */
  89         SND_CARD_TYPE_WAVEFRONT = SNDRV_CARD_TYPE_WAVEFRONT,
  90         /** Turtle Beach Tropez */
  91         SND_CARD_TYPE_TROPEZ = SNDRV_CARD_TYPE_TROPEZ,
  92         /** Turtle Beach Tropez+ */
  93         SND_CARD_TYPE_TROPEZPLUS = SNDRV_CARD_TYPE_TROPEZPLUS,
  94         /** Turtle Beach Maui */
  95         SND_CARD_TYPE_MAUI = SNDRV_CARD_TYPE_MAUI,
  96         /** CMI8330 */
  97         SND_CARD_TYPE_CMI8330 = SNDRV_CARD_TYPE_CMI8330,
  98         /** Dummy (/dev/null) soundcard */
  99         SND_CARD_TYPE_DUMMY = SNDRV_CARD_TYPE_DUMMY,
 100         /** Avance Logic ALS100 */
 101         SND_CARD_TYPE_ALS100 = SNDRV_CARD_TYPE_ALS100,
 102         /** Obsolete */
 103         SND_CARD_TYPE_SHARE = SNDRV_CARD_TYPE_SHARE,
 104         /** SiS SI7018 */
 105         SND_CARD_TYPE_SI_7018 = SNDRV_CARD_TYPE_SI_7018,
 106         /** Opti93x */
 107         SND_CARD_TYPE_OPTI93X = SNDRV_CARD_TYPE_OPTI93X,
 108         /** MidiTimePiece AV multiport MIDI */
 109         SND_CARD_TYPE_MTPAV = SNDRV_CARD_TYPE_MTPAV,
 110         /** Virtual MIDI */
 111         SND_CARD_TYPE_VIRMIDI = SNDRV_CARD_TYPE_VIRMIDI,
 112         /** EMU10K1 (SB Live, Emu APS) */
 113         SND_CARD_TYPE_EMU10K1 = SNDRV_CARD_TYPE_EMU10K1,
 114         /** RME Hammerfall */
 115         SND_CARD_TYPE_HAMMERFALL = SNDRV_CARD_TYPE_HAMMERFALL,
 116         /** RME Hammerfall light */
 117         SND_CARD_TYPE_HAMMERFALL_LIGHT = SNDRV_CARD_TYPE_HAMMERFALL_LIGHT,
 118         /** ICE1712 (Envy24) */
 119         SND_CARD_TYPE_ICE1712 = SNDRV_CARD_TYPE_ICE1712,
 120         /** CMI8338 */
 121         SND_CARD_TYPE_CMI8338 = SNDRV_CARD_TYPE_CMI8338,
 122         /** CMI8738 */
 123         SND_CARD_TYPE_CMI8738 = SNDRV_CARD_TYPE_CMI8738,
 124         /** Analog Device AD1816A */
 125         SND_CARD_TYPE_AD1816A = SNDRV_CARD_TYPE_AD1816A,
 126         /** Intel i8x0 */
 127         SND_CARD_TYPE_INTEL8X0 = SNDRV_CARD_TYPE_INTEL8X0,
 128         /** ESS Maestro 1 (old) */
 129         SND_CARD_TYPE_ESS_ESOLDM1 = SNDRV_CARD_TYPE_ESS_ESOLDM1,
 130         /** ESS Maestro 2 */
 131         SND_CARD_TYPE_ESS_ES1968 = SNDRV_CARD_TYPE_ESS_ES1968,
 132         /** ESS Maestro 2E */
 133         SND_CARD_TYPE_ESS_ES1978 = SNDRV_CARD_TYPE_ESS_ES1978,
 134         /** RME Digi96 */
 135         SND_CARD_TYPE_DIGI96 = SNDRV_CARD_TYPE_DIGI96,
 136         /** VIA SouthBridge 686A/686B */
 137         SND_CARD_TYPE_VIA82C686A = SNDRV_CARD_TYPE_VIA82C686A,
 138         /** Forte Media FM801 */
 139         SND_CARD_TYPE_FM801 = SNDRV_CARD_TYPE_FM801,
 140         /** Aztech AZT2320 */
 141         SND_CARD_TYPE_AZT2320 = SNDRV_CARD_TYPE_AZT2320,
 142         /** Prodif Plus */
 143         SND_CARD_TYPE_PRODIF_PLUS = SNDRV_CARD_TYPE_PRODIF_PLUS,
 144         /** Yamaha PCI */
 145         SND_CARD_TYPE_YMFPCI = SNDRV_CARD_TYPE_YMFPCI,
 146         /** Cirrus Logic CS4281 */
 147         SND_CARD_TYPE_CS4281 = SNDRV_CARD_TYPE_CS4281,
 148         /** Generic MPU401 UART */
 149         SND_CARD_TYPE_MPU401_UART = SNDRV_CARD_TYPE_MPU401_UART,
 150         /** Avance Logic ALS4000 */
 151         SND_CARD_TYPE_ALS4000 = SNDRV_CARD_TYPE_ALS4000,
 152         /** ESS Allegro 1 */
 153         SND_CARD_TYPE_ALLEGRO_1 = SNDRV_CARD_TYPE_ALLEGRO_1,
 154         /** ESS Allegro */
 155         SND_CARD_TYPE_ALLEGRO = SNDRV_CARD_TYPE_ALLEGRO,
 156         /** ESS Maestro 3 */
 157         SND_CARD_TYPE_MAESTRO3 = SNDRV_CARD_TYPE_MAESTRO3,
 158         /** AWACS */
 159         SND_CARD_TYPE_AWACS = SNDRV_CARD_TYPE_AWACS,
 160         /** NeoMagic NM256AV */
 161         SND_CARD_TYPE_NM256AV = SNDRV_CARD_TYPE_NM256AV,
 162         /** NeoMagic NM256ZX */
 163         SND_CARD_TYPE_NM256ZX = SNDRV_CARD_TYPE_NM256ZX,
 164         /** VIA VT8233 bridge */
 165         SND_CARD_TYPE_VIA8233 = SNDRV_CARD_TYPE_VIA8233,
 166         SND_CARD_TYPE_LAST = SNDRV_CARD_TYPE_LAST,
 167 } snd_card_type_t;
 168
 169 /** CTL element type */
 170 typedef enum _snd_ctl_elem_type {
 171         /** Invalid type */
 172         SND_CTL_ELEM_TYPE_NONE = SNDRV_CTL_ELEM_TYPE_NONE,
 173         /** Boolean contents */
 174         SND_CTL_ELEM_TYPE_BOOLEAN = SNDRV_CTL_ELEM_TYPE_BOOLEAN,
 175         /** Integer contents */
 176         SND_CTL_ELEM_TYPE_INTEGER = SNDRV_CTL_ELEM_TYPE_INTEGER,
 177         /** Enumerated contents */
 178         SND_CTL_ELEM_TYPE_ENUMERATED = SNDRV_CTL_ELEM_TYPE_ENUMERATED,
 179         /** Bytes contents */
 180         SND_CTL_ELEM_TYPE_BYTES = SNDRV_CTL_ELEM_TYPE_BYTES,
 181         /** IEC958 (S/PDIF) setting content */
 182         SND_CTL_ELEM_TYPE_IEC958 = SNDRV_CTL_ELEM_TYPE_IEC958,
 183         SND_CTL_ELEM_TYPE_LAST = SNDRV_CTL_ELEM_TYPE_LAST,
 184 } snd_ctl_elem_type_t;
 185
 186 /** CTL related interface */
 187 typedef enum _snd_ctl_elem_iface {
 188         /** Card level */
 189         SND_CTL_ELEM_IFACE_CARD = SNDRV_CTL_ELEM_IFACE_CARD,
 190         /** Hardware dependent device */
 191         SND_CTL_ELEM_IFACE_HWDEP = SNDRV_CTL_ELEM_IFACE_HWDEP,
 192         /** Mixer */
 193         SND_CTL_ELEM_IFACE_MIXER = SNDRV_CTL_ELEM_IFACE_MIXER,
 194         /** PCM */
 195         SND_CTL_ELEM_IFACE_PCM = SNDRV_CTL_ELEM_IFACE_PCM,
 196         /** RawMidi */
 197         SND_CTL_ELEM_IFACE_RAWMIDI = SNDRV_CTL_ELEM_IFACE_RAWMIDI,
 198         /** Timer */
 199         SND_CTL_ELEM_IFACE_TIMER = SNDRV_CTL_ELEM_IFACE_TIMER,
 200         /** Sequencer */
 201         SND_CTL_ELEM_IFACE_SEQUENCER = SNDRV_CTL_ELEM_IFACE_SEQUENCER,
 202         SND_CTL_ELEM_IFACE_LAST = SNDRV_CTL_ELEM_IFACE_LAST,
 203 } snd_ctl_elem_iface_t;
 204
 205 /** Event class */
 206 typedef enum _snd_ctl_event_type {
 207         /** Elements related event */
 208         SND_CTL_EVENT_ELEM = SNDRV_CTL_EVENT_ELEM,
 209         SND_CTL_EVENT_LAST = SNDRV_CTL_EVENT_LAST,
 210 }snd_ctl_event_type_t;
 211
 212 /** Element has been removed (Warning: test this first and if set don't
 213  * test the other masks) \hideinitializer */
 214 #define SND_CTL_EVENT_MASK_REMOVE SNDRV_CTL_EVENT_MASK_REMOVE
 215 /** Element has been added \hideinitializer */
 216 #define SND_CTL_EVENT_MASK_ADD SNDRV_CTL_EVENT_MASK_ADD
 217 /** Element info has been changed \hideinitializer */
 218 #define SND_CTL_EVENT_MASK_INFO SNDRV_CTL_EVENT_MASK_INFO
 219 /** Element value has been changed \hideinitializer */
 220 #define SND_CTL_EVENT_MASK_VALUE SNDRV_CTL_EVENT_MASK_VALUE
 221
 222 #define SND_CTL_NAME_IEC958 SNDRV_CTL_NAME_IEC958
 223
 224 /** CTL type */
 225 typedef enum _snd_ctl_type {
 226         /** Kernel level CTL */
 227         SND_CTL_TYPE_HW,
 228         /** Shared memory client CTL */
 229         SND_CTL_TYPE_SHM,
 230         /** INET client CTL (not yet implemented) */
 231         SND_CTL_TYPE_INET
 232 } snd_ctl_type_t;
 233
 234 /** Non blocking mode \hideinitializer */
 235 #define SND_CTL_NONBLOCK                0x0001
 236
 237 /** Async notification \hideinitializer */
 238 #define SND_CTL_ASYNC                   0x0002
 239
 240 /** CTL handle */
 241 typedef struct _snd_ctl snd_ctl_t;
 242
 243 #ifdef __cplusplus
 244 extern "C" {
 245 #endif
 246
 247 int snd_card_load(int card);
 248 int snd_card_next(int *card);
 249 int snd_card_get_index(const char *name);
 250 int snd_card_get_name(int card, char **name);
 251 int snd_card_get_longname(int card, char **name);
 252
 253 int snd_defaults_card(void);
 254 int snd_defaults_mixer_card(void);
 255 int snd_defaults_pcm_card(void);
 256 int snd_defaults_pcm_device(void);
 257 int snd_defaults_rawmidi_card(void);
 258 int snd_defaults_rawmidi_device(void);
 259
 260 int snd_ctl_open(snd_ctl_t **ctl, const char *name, int mode);
 261 int snd_ctl_close(snd_ctl_t *ctl);
 262 int snd_ctl_nonblock(snd_ctl_t *ctl, int nonblock);
 263 int snd_ctl_async(snd_ctl_t *ctl, int sig, pid_t pid);
 264 int snd_ctl_poll_descriptors_count(snd_ctl_t *ctl);
 265 int snd_ctl_poll_descriptors(snd_ctl_t *ctl, struct pollfd *pfds, unsigned int space);
 266 int snd_ctl_subscribe_events(snd_ctl_t *ctl, int subscribe);
 267 int snd_ctl_card_info(snd_ctl_t *ctl, snd_ctl_card_info_t *info);
 268 int snd_ctl_elem_list(snd_ctl_t *ctl, snd_ctl_elem_list_t * list);
 269 int snd_ctl_elem_info(snd_ctl_t *ctl, snd_ctl_elem_info_t *info);
 270 int snd_ctl_elem_read(snd_ctl_t *ctl, snd_ctl_elem_value_t *value);
 271 int snd_ctl_elem_write(snd_ctl_t *ctl, snd_ctl_elem_value_t *value);
 272 int snd_ctl_hwdep_next_device(snd_ctl_t *ctl, int * device);
 273 int snd_ctl_hwdep_info(snd_ctl_t *ctl, snd_hwdep_info_t * info);
 274 int snd_ctl_pcm_next_device(snd_ctl_t *ctl, int *device);
 275 int snd_ctl_pcm_surround_next_device(snd_ctl_t *ctl, snd_pcm_surround_type_t type, int *device);
 276 int snd_ctl_pcm_info(snd_ctl_t *ctl, snd_pcm_info_t * info);
 277 int snd_ctl_pcm_prefer_subdevice(snd_ctl_t *ctl, int subdev);
 278 int snd_ctl_rawmidi_next_device(snd_ctl_t *ctl, int * device);
 279 int snd_ctl_rawmidi_info(snd_ctl_t *ctl, snd_rawmidi_info_t * info);
 280 int snd_ctl_rawmidi_prefer_subdevice(snd_ctl_t *ctl, int subdev);
 281
 282 int snd_ctl_read(snd_ctl_t *ctl, snd_ctl_event_t *event);
 283 int snd_ctl_wait(snd_ctl_t *ctl, int timeout);
 284 const char *snd_ctl_name(snd_ctl_t *ctl);
 285 snd_ctl_type_t snd_ctl_type(snd_ctl_t *ctl);
 286
 287 void snd_ctl_elem_set_bytes(snd_ctl_elem_value_t *obj, void *data, size_t size);
 288 const char *snd_ctl_elem_type_name(snd_ctl_elem_type_t type);
 289 const char *snd_ctl_elem_iface_name(snd_ctl_elem_iface_t iface);
 290 const char *snd_ctl_event_type_name(snd_ctl_event_type_t type);
 291
 292 unsigned int snd_ctl_event_elem_get_mask(const snd_ctl_event_t *obj);
 293 unsigned int snd_ctl_event_elem_get_numid(const snd_ctl_event_t *obj);
 294 void snd_ctl_event_elem_get_id(const snd_ctl_event_t *obj, snd_ctl_elem_id_t *ptr);
 295 snd_ctl_elem_iface_t snd_ctl_event_elem_get_interface(const snd_ctl_event_t *obj);
 296 unsigned int snd_ctl_event_elem_get_device(const snd_ctl_event_t *obj);
 297 unsigned int snd_ctl_event_elem_get_subdevice(const snd_ctl_event_t *obj);
 298 const char *snd_ctl_event_elem_get_name(const snd_ctl_event_t *obj);
 299 unsigned int snd_ctl_event_elem_get_index(const snd_ctl_event_t *obj);
 300
 301 int snd_ctl_elem_list_alloc_space(snd_ctl_elem_list_t *obj, unsigned int entries);
 302 void snd_ctl_elem_list_free_space(snd_ctl_elem_list_t *obj);
 303
 304 #ifdef __cplusplus
 305 }
 306 #endif
 307
 308 /*
 309  *  Highlevel API for controls
 310  */
 311
 312 /** HCTL element handle */
 313 typedef struct _snd_hctl_elem snd_hctl_elem_t;
 314
 315 /** HCTL handle */
 316 typedef struct _snd_hctl snd_hctl_t;
 317
 318 #ifdef __cplusplus
 319 extern "C" {
 320 #endif
 321
 322 /**
 323  * \brief Compare function for sorting HCTL elements
 324  * \param e1 First element
 325  * \param e2 Second element
 326  * \return -1 if e1 < e2, 0 if e1 == e2, 1 if e1 > e2
 327  */
 328 typedef int (*snd_hctl_compare_t)(const snd_hctl_elem_t *e1,
 329                                   const snd_hctl_elem_t *e2);
 330 int snd_hctl_compare_fast(const snd_hctl_elem_t *c1,
 331                           const snd_hctl_elem_t *c2);
 332 /**
 333  * \brief HCTL callback function
 334  * \param hctl HCTL handle
 335  * \param mask event mask
 336  * \param elem related HCTL element (if any)
 337  * \return 0 on success otherwise a negative error code
 338  */
 339 typedef int (*snd_hctl_callback_t)(snd_hctl_t *hctl,
 340                                    unsigned int mask,
 341                                    snd_hctl_elem_t *elem);
 342 /**
 343  * \brief HCTL element callback function
 344  * \param elem HCTL element
 345  * \param mask event mask
 346  * \return 0 on success otherwise a negative error code
 347  */
 348 typedef int (*snd_hctl_elem_callback_t)(snd_hctl_elem_t *elem,
 349                                         unsigned int mask);
 350
 351 int snd_hctl_open(snd_hctl_t **hctl, const char *name, int mode);
 352 int snd_hctl_close(snd_hctl_t *hctl);
 353 int snd_hctl_nonblock(snd_hctl_t *hctl, int nonblock);
 354 int snd_hctl_async(snd_hctl_t *hctl, int sig, pid_t pid);
 355 int snd_hctl_poll_descriptors_count(snd_hctl_t *hctl);
 356 int snd_hctl_poll_descriptors(snd_hctl_t *hctl, struct pollfd *pfds, unsigned int space);
 357 unsigned int snd_hctl_get_count(snd_hctl_t *hctl);
 358 int snd_hctl_set_compare(snd_hctl_t *hctl, snd_hctl_compare_t hsort);
 359 snd_hctl_elem_t *snd_hctl_first_elem(snd_hctl_t *hctl);
 360 snd_hctl_elem_t *snd_hctl_last_elem(snd_hctl_t *hctl);
 361 snd_hctl_elem_t *snd_hctl_find_elem(snd_hctl_t *hctl, const snd_ctl_elem_id_t *id);
 362 void snd_hctl_set_callback(snd_hctl_t *hctl, snd_hctl_callback_t callback);
 363 void snd_hctl_set_callback_private(snd_hctl_t *hctl, void *data);
 364 void *snd_hctl_get_callback_private(snd_hctl_t *hctl);
 365 int snd_hctl_load(snd_hctl_t *hctl);
 366 int snd_hctl_free(snd_hctl_t *hctl);
 367 int snd_hctl_handle_events(snd_hctl_t *hctl);
 368 const char *snd_hctl_name(snd_hctl_t *hctl);
 369 snd_ctl_type_t snd_hctl_type(snd_hctl_t *hctl);
 370 int snd_hctl_wait(snd_hctl_t *hctl, int timeout);
 371
 372 snd_hctl_elem_t *snd_hctl_elem_next(snd_hctl_elem_t *elem);
 373 snd_hctl_elem_t *snd_hctl_elem_prev(snd_hctl_elem_t *elem);
 374 int snd_hctl_elem_info(snd_hctl_elem_t *elem, snd_ctl_elem_info_t * info);
 375 int snd_hctl_elem_read(snd_hctl_elem_t *elem, snd_ctl_elem_value_t * value);
 376 int snd_hctl_elem_write(snd_hctl_elem_t *elem, snd_ctl_elem_value_t * value);
 377
 378 snd_hctl_t *snd_hctl_elem_get_hctl(snd_hctl_elem_t *elem);
 379
 380 size_t snd_ctl_elem_id_sizeof(void);
 381 /** \hideinitializer
 382  * \brief allocate an invalid #snd_ctl_elem_id_t using standard alloca
 383  * \param ptr returned pointer
 384  */
 385 #define snd_ctl_elem_id_alloca(ptr) do { assert(ptr); *ptr = (snd_ctl_elem_id_t *) alloca(snd_ctl_elem_id_sizeof()); memset(*ptr, 0, snd_ctl_elem_id_sizeof()); } while (0)
 386 int snd_ctl_elem_id_malloc(snd_ctl_elem_id_t **ptr);
 387 void snd_ctl_elem_id_free(snd_ctl_elem_id_t *obj);
 388 void snd_ctl_elem_id_copy(snd_ctl_elem_id_t *dst, const snd_ctl_elem_id_t *src);
 389
 390 unsigned int snd_ctl_elem_id_get_numid(const snd_ctl_elem_id_t *obj);
 391
 392 snd_ctl_elem_iface_t snd_ctl_elem_id_get_interface(const snd_ctl_elem_id_t *obj);
 393
 394 unsigned int snd_ctl_elem_id_get_device(const snd_ctl_elem_id_t *obj);
 395
 396 unsigned int snd_ctl_elem_id_get_subdevice(const snd_ctl_elem_id_t *obj);
 397
 398 const char *snd_ctl_elem_id_get_name(const snd_ctl_elem_id_t *obj);
 399
 400 unsigned int snd_ctl_elem_id_get_index(const snd_ctl_elem_id_t *obj);
 401
 402 void snd_ctl_elem_id_set_numid(snd_ctl_elem_id_t *obj, unsigned int val);
 403
 404 void snd_ctl_elem_id_set_interface(snd_ctl_elem_id_t *obj, snd_ctl_elem_iface_t val);
 405
 406 void snd_ctl_elem_id_set_device(snd_ctl_elem_id_t *obj, unsigned int val);
 407
 408 void snd_ctl_elem_id_set_subdevice(snd_ctl_elem_id_t *obj, unsigned int val);
 409
 410 void snd_ctl_elem_id_set_name(snd_ctl_elem_id_t *obj, const char *val);
 411
 412 void snd_ctl_elem_id_set_index(snd_ctl_elem_id_t *obj, unsigned int val);
 413
 414 size_t snd_ctl_card_info_sizeof(void);
 415 /** \hideinitializer
 416  * \brief allocate an invalid #snd_ctl_card_info_t using standard alloca
 417  * \param ptr returned pointer
 418  */
 419 #define snd_ctl_card_info_alloca(ptr) do { assert(ptr); *ptr = (snd_ctl_card_info_t *) alloca(snd_ctl_card_info_sizeof()); memset(*ptr, 0, snd_ctl_card_info_sizeof()); } while (0)
 420 int snd_ctl_card_info_malloc(snd_ctl_card_info_t **ptr);
 421 void snd_ctl_card_info_free(snd_ctl_card_info_t *obj);
 422 void snd_ctl_card_info_copy(snd_ctl_card_info_t *dst, const snd_ctl_card_info_t *src);
 423
 424 int snd_ctl_card_info_get_card(const snd_ctl_card_info_t *obj);
 425
 426 snd_card_type_t snd_ctl_card_info_get_type(const snd_ctl_card_info_t *obj);
 427
 428 const char *snd_ctl_card_info_get_id(const snd_ctl_card_info_t *obj);
 429
 430 const char *snd_ctl_card_info_get_abbreviation(const snd_ctl_card_info_t *obj);
 431
 432 const char *snd_ctl_card_info_get_name(const snd_ctl_card_info_t *obj);
 433
 434 const char *snd_ctl_card_info_get_longname(const snd_ctl_card_info_t *obj);
 435
 436 const char *snd_ctl_card_info_get_mixerid(const snd_ctl_card_info_t *obj);
 437
 438 const char *snd_ctl_card_info_get_mixername(const snd_ctl_card_info_t *obj);
 439
 440 size_t snd_ctl_event_sizeof(void);
 441 /** \hideinitializer
 442  * \brief allocate an invalid #snd_ctl_event_t using standard alloca
 443  * \param ptr returned pointer
 444  */
 445 #define snd_ctl_event_alloca(ptr) do { assert(ptr); *ptr = (snd_ctl_event_t *) alloca(snd_ctl_event_sizeof()); memset(*ptr, 0, snd_ctl_event_sizeof()); } while (0)
 446 int snd_ctl_event_malloc(snd_ctl_event_t **ptr);
 447 void snd_ctl_event_free(snd_ctl_event_t *obj);
 448 void snd_ctl_event_copy(snd_ctl_event_t *dst, const snd_ctl_event_t *src);
 449
 450 snd_ctl_event_type_t snd_ctl_event_get_type(const snd_ctl_event_t *obj);
 451
 452 size_t snd_ctl_elem_list_sizeof(void);
 453 /** \hideinitializer
 454  * \brief allocate an invalid #snd_ctl_elem_list_t using standard alloca
 455  * \param ptr returned pointer
 456  */
 457 #define snd_ctl_elem_list_alloca(ptr) do { assert(ptr); *ptr = (snd_ctl_elem_list_t *) alloca(snd_ctl_elem_list_sizeof()); memset(*ptr, 0, snd_ctl_elem_list_sizeof()); } while (0)
 458 int snd_ctl_elem_list_malloc(snd_ctl_elem_list_t **ptr);
 459 void snd_ctl_elem_list_free(snd_ctl_elem_list_t *obj);
 460 void snd_ctl_elem_list_copy(snd_ctl_elem_list_t *dst, const snd_ctl_elem_list_t *src);
 461
 462 void snd_ctl_elem_list_set_offset(snd_ctl_elem_list_t *obj, unsigned int val);
 463
 464 unsigned int snd_ctl_elem_list_get_used(const snd_ctl_elem_list_t *obj);
 465
 466 unsigned int snd_ctl_elem_list_get_count(const snd_ctl_elem_list_t *obj);
 467
 468 void snd_ctl_elem_list_get_id(const snd_ctl_elem_list_t *obj, unsigned int idx, snd_ctl_elem_id_t *ptr);
 469
 470 unsigned int snd_ctl_elem_list_get_numid(const snd_ctl_elem_list_t *obj, unsigned int idx);
 471
 472 snd_ctl_elem_iface_t snd_ctl_elem_list_get_interface(const snd_ctl_elem_list_t *obj, unsigned int idx);
 473
 474 unsigned int snd_ctl_elem_list_get_device(const snd_ctl_elem_list_t *obj, unsigned int idx);
 475
 476 unsigned int snd_ctl_elem_list_get_subdevice(const snd_ctl_elem_list_t *obj, unsigned int idx);
 477
 478 const char *snd_ctl_elem_list_get_name(const snd_ctl_elem_list_t *obj, unsigned int idx);
 479
 480 unsigned int snd_ctl_elem_list_get_index(const snd_ctl_elem_list_t *obj, unsigned int idx);
 481
 482 size_t snd_ctl_elem_info_sizeof(void);
 483 /** \hideinitializer
 484  * \brief allocate an invalid #snd_ctl_elem_info_t using standard alloca
 485  * \param ptr returned pointer
 486  */
 487 #define snd_ctl_elem_info_alloca(ptr) do { assert(ptr); *ptr = (snd_ctl_elem_info_t *) alloca(snd_ctl_elem_info_sizeof()); memset(*ptr, 0, snd_ctl_elem_info_sizeof()); } while (0)
 488 int snd_ctl_elem_info_malloc(snd_ctl_elem_info_t **ptr);
 489 void snd_ctl_elem_info_free(snd_ctl_elem_info_t *obj);
 490 void snd_ctl_elem_info_copy(snd_ctl_elem_info_t *dst, const snd_ctl_elem_info_t *src);
 491
 492 snd_ctl_elem_type_t snd_ctl_elem_info_get_type(const snd_ctl_elem_info_t *obj);
 493
 494 int snd_ctl_elem_info_is_readable(const snd_ctl_elem_info_t *obj);
 495
 496 int snd_ctl_elem_info_is_writable(const snd_ctl_elem_info_t *obj);
 497
 498 int snd_ctl_elem_info_is_volatile(const snd_ctl_elem_info_t *obj);
 499
 500 int snd_ctl_elem_info_is_inactive(const snd_ctl_elem_info_t *obj);
 501
 502 int snd_ctl_elem_info_is_locked(const snd_ctl_elem_info_t *obj);
 503
 504 int snd_ctl_elem_info_is_indirect(const snd_ctl_elem_info_t *obj);
 505
 506 unsigned int snd_ctl_elem_info_get_count(const snd_ctl_elem_info_t *obj);
 507
 508 long snd_ctl_elem_info_get_min(const snd_ctl_elem_info_t *obj);
 509
 510 long snd_ctl_elem_info_get_max(const snd_ctl_elem_info_t *obj);
 511
 512 long snd_ctl_elem_info_get_step(const snd_ctl_elem_info_t *obj);
 513
 514 unsigned int snd_ctl_elem_info_get_items(const snd_ctl_elem_info_t *obj);
 515
 516 void snd_ctl_elem_info_set_item(snd_ctl_elem_info_t *obj, unsigned int val);
 517
 518 const char *snd_ctl_elem_info_get_item_name(const snd_ctl_elem_info_t *obj);
 519
 520 void snd_ctl_elem_info_get_id(const snd_ctl_elem_info_t *obj, snd_ctl_elem_id_t *ptr);
 521
 522 unsigned int snd_ctl_elem_info_get_numid(const snd_ctl_elem_info_t *obj);
 523
 524 snd_ctl_elem_iface_t snd_ctl_elem_info_get_interface(const snd_ctl_elem_info_t *obj);
 525
 526 unsigned int snd_ctl_elem_info_get_device(const snd_ctl_elem_info_t *obj);
 527
 528 unsigned int snd_ctl_elem_info_get_subdevice(const snd_ctl_elem_info_t *obj);
 529
 530 const char *snd_ctl_elem_info_get_name(const snd_ctl_elem_info_t *obj);
 531
 532 unsigned int snd_ctl_elem_info_get_index(const snd_ctl_elem_info_t *obj);
 533
 534 void snd_ctl_elem_info_set_id(snd_ctl_elem_info_t *obj, const snd_ctl_elem_id_t *ptr);
 535
 536 void snd_ctl_elem_info_set_numid(snd_ctl_elem_info_t *obj, unsigned int val);
 537
 538 void snd_ctl_elem_info_set_interface(snd_ctl_elem_info_t *obj, snd_ctl_elem_iface_t val);
 539
 540 void snd_ctl_elem_info_set_device(snd_ctl_elem_info_t *obj, unsigned int val);
 541
 542 void snd_ctl_elem_info_set_subdevice(snd_ctl_elem_info_t *obj, unsigned int val);
 543
 544 void snd_ctl_elem_info_set_name(snd_ctl_elem_info_t *obj, const char *val);
 545
 546 void snd_ctl_elem_info_set_index(snd_ctl_elem_info_t *obj, unsigned int val);
 547
 548 size_t snd_ctl_elem_value_sizeof(void);
 549 /** \hideinitializer
 550  * \brief allocate an invalid #snd_ctl_elem_value_t using standard alloca
 551  * \param ptr returned pointer
 552  */
 553 #define snd_ctl_elem_value_alloca(ptr) do { assert(ptr); *ptr = (snd_ctl_elem_value_t *) alloca(snd_ctl_elem_value_sizeof()); memset(*ptr, 0, snd_ctl_elem_value_sizeof()); } while (0)
 554 int snd_ctl_elem_value_malloc(snd_ctl_elem_value_t **ptr);
 555 void snd_ctl_elem_value_free(snd_ctl_elem_value_t *obj);
 556 void snd_ctl_elem_value_copy(snd_ctl_elem_value_t *dst, const snd_ctl_elem_value_t *src);
 557
 558 void snd_ctl_elem_value_get_id(const snd_ctl_elem_value_t *obj, snd_ctl_elem_id_t *ptr);
 559
 560 unsigned int snd_ctl_elem_value_get_numid(const snd_ctl_elem_value_t *obj);
 561
 562 snd_ctl_elem_iface_t snd_ctl_elem_value_get_interface(const snd_ctl_elem_value_t *obj);
 563
 564 unsigned int snd_ctl_elem_value_get_device(const snd_ctl_elem_value_t *obj);
 565
 566 unsigned int snd_ctl_elem_value_get_subdevice(const snd_ctl_elem_value_t *obj);
 567
 568 const char *snd_ctl_elem_value_get_name(const snd_ctl_elem_value_t *obj);
 569
 570 unsigned int snd_ctl_elem_value_get_index(const snd_ctl_elem_value_t *obj);
 571
 572 void snd_ctl_elem_value_set_id(snd_ctl_elem_value_t *obj, const snd_ctl_elem_id_t *ptr);
 573
 574 void snd_ctl_elem_value_set_numid(snd_ctl_elem_value_t *obj, unsigned int val);
 575
 576 void snd_ctl_elem_value_set_interface(snd_ctl_elem_value_t *obj, snd_ctl_elem_iface_t val);
 577
 578 void snd_ctl_elem_value_set_device(snd_ctl_elem_value_t *obj, unsigned int val);
 579
 580 void snd_ctl_elem_value_set_subdevice(snd_ctl_elem_value_t *obj, unsigned int val);
 581
 582 void snd_ctl_elem_value_set_name(snd_ctl_elem_value_t *obj, const char *val);
 583
 584 void snd_ctl_elem_value_set_index(snd_ctl_elem_value_t *obj, unsigned int val);
 585
 586 int snd_ctl_elem_value_get_boolean(const snd_ctl_elem_value_t *obj, unsigned int idx);
 587
 588 long snd_ctl_elem_value_get_integer(const snd_ctl_elem_value_t *obj, unsigned int idx);
 589
 590 unsigned int snd_ctl_elem_value_get_enumerated(const snd_ctl_elem_value_t *obj, unsigned int idx);
 591
 592 unsigned char snd_ctl_elem_value_get_byte(const snd_ctl_elem_value_t *obj, unsigned int idx);
 593
 594 void snd_ctl_elem_value_set_boolean(snd_ctl_elem_value_t *obj, unsigned int idx, long val);
 595
 596 void snd_ctl_elem_value_set_integer(snd_ctl_elem_value_t *obj, unsigned int idx, long val);
 597
 598 void snd_ctl_elem_value_set_enumerated(snd_ctl_elem_value_t *obj, unsigned int idx, unsigned int val);
 599
 600 void snd_ctl_elem_value_set_byte(snd_ctl_elem_value_t *obj, unsigned int idx, unsigned char val);
 601
 602 const void * snd_ctl_elem_value_get_bytes(const snd_ctl_elem_value_t *obj);
 603
 604 void snd_ctl_elem_value_get_iec958(const snd_ctl_elem_value_t *obj, snd_aes_iec958_t *ptr);
 605
 606 void snd_ctl_elem_value_set_iec958(snd_ctl_elem_value_t *obj, const snd_aes_iec958_t *ptr);
 607
 608 void snd_hctl_elem_get_id(const snd_hctl_elem_t *obj, snd_ctl_elem_id_t *ptr);
 609
 610 unsigned int snd_hctl_elem_get_numid(const snd_hctl_elem_t *obj);
 611
 612 snd_ctl_elem_iface_t snd_hctl_elem_get_interface(const snd_hctl_elem_t *obj);
 613
 614 unsigned int snd_hctl_elem_get_device(const snd_hctl_elem_t *obj);
 615
 616 unsigned int snd_hctl_elem_get_subdevice(const snd_hctl_elem_t *obj);
 617
 618 const char *snd_hctl_elem_get_name(const snd_hctl_elem_t *obj);
 619
 620 unsigned int snd_hctl_elem_get_index(const snd_hctl_elem_t *obj);
 621
 622 void snd_hctl_elem_set_callback(snd_hctl_elem_t *obj, snd_hctl_elem_callback_t val);
 623
 624 void * snd_hctl_elem_get_callback_private(const snd_hctl_elem_t *obj);
 625
 626 void snd_hctl_elem_set_callback_private(snd_hctl_elem_t *obj, void * val);
 627
 628 #ifdef __cplusplus
 629 }
 630 #endif
 631