include/control.h

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