snd_ctl_t *ctl;
int err;
int result;
- err = snd_ctl_open(&ctl, client->name);
+ err = snd_ctl_open(&ctl, client->name, SND_CTL_NONBLOCK);
if (err < 0)
return err;
client->device.control.handle = ctl;
****************************************************************************/
typedef struct sndrv_aes_iec958 snd_aes_iec958_t;
+
+/** CTL card info container */
typedef struct _snd_ctl_card_info snd_ctl_card_info_t;
+
+/** CTL element identificator container */
typedef struct _snd_ctl_elem_id snd_ctl_elem_id_t;
+
+/** CTL element identificator list container */
typedef struct _snd_ctl_elem_list snd_ctl_elem_list_t;
+
+/** CTL element info container */
typedef struct _snd_ctl_elem_info snd_ctl_elem_info_t;
+
+/** CTL element value container */
typedef struct _snd_ctl_elem_value snd_ctl_elem_value_t;
+
+/** CTL event container */
typedef struct _snd_ctl_event snd_ctl_event_t;
-#ifdef SND_ENUM_TYPECHECK
-typedef struct __snd_card_type *snd_card_type_t;
-typedef struct __snd_ctl_elem_type *snd_ctl_elem_type_t;
-typedef struct __snd_ctl_elem_iface *snd_ctl_elem_iface_t;
-typedef struct __snd_ctl_event_type *snd_ctl_event_type_t;
-#else
-typedef enum sndrv_card_type snd_card_type_t;
-typedef enum sndrv_ctl_elem_type snd_ctl_elem_type_t;
-typedef enum sndrv_ctl_elem_iface snd_ctl_elem_iface_t;
-typedef enum sndrv_ctl_event_type snd_ctl_event_type_t;
-#endif
+/** Card type */
+typedef enum _snd_card_type {
+ SND_CARD_TYPE_GUS_CLASSIC = SNDRV_CARD_TYPE_GUS_CLASSIC,
+ SND_CARD_TYPE_GUS_EXTREME = SNDRV_CARD_TYPE_GUS_EXTREME,
+ SND_CARD_TYPE_GUS_ACE = SNDRV_CARD_TYPE_GUS_ACE,
+ SND_CARD_TYPE_GUS_MAX = SNDRV_CARD_TYPE_GUS_MAX,
+ SND_CARD_TYPE_AMD_INTERWAVE = SNDRV_CARD_TYPE_AMD_INTERWAVE,
+ SND_CARD_TYPE_SB_10 = SNDRV_CARD_TYPE_SB_10,
+ SND_CARD_TYPE_SB_20 = SNDRV_CARD_TYPE_SB_20,
+ SND_CARD_TYPE_SB_PRO = SNDRV_CARD_TYPE_SB_PRO,
+ SND_CARD_TYPE_SB_16 = SNDRV_CARD_TYPE_SB_16,
+ SND_CARD_TYPE_SB_AWE = SNDRV_CARD_TYPE_SB_AWE,
+ SND_CARD_TYPE_ESS_ES1688 = SNDRV_CARD_TYPE_ESS_ES1688,
+ SND_CARD_TYPE_OPL3_SA2 = SNDRV_CARD_TYPE_OPL3_SA2,
+ SND_CARD_TYPE_MOZART = SNDRV_CARD_TYPE_MOZART,
+ SND_CARD_TYPE_S3_SONICVIBES = SNDRV_CARD_TYPE_S3_SONICVIBES,
+ SND_CARD_TYPE_ENS1370 = SNDRV_CARD_TYPE_ENS1370,
+ SND_CARD_TYPE_ENS1371 = SNDRV_CARD_TYPE_ENS1371,
+ SND_CARD_TYPE_CS4232 = SNDRV_CARD_TYPE_CS4232,
+ SND_CARD_TYPE_CS4236 = SNDRV_CARD_TYPE_CS4236,
+ SND_CARD_TYPE_AMD_INTERWAVE_STB = SNDRV_CARD_TYPE_AMD_INTERWAVE_STB,
+ SND_CARD_TYPE_ESS_ES1938 = SNDRV_CARD_TYPE_ESS_ES1938,
+ SND_CARD_TYPE_ESS_ES18XX = SNDRV_CARD_TYPE_ESS_ES18XX,
+ SND_CARD_TYPE_CS4231 = SNDRV_CARD_TYPE_CS4231,
+ SND_CARD_TYPE_OPTI92X = SNDRV_CARD_TYPE_OPTI92X,
+ SND_CARD_TYPE_SERIAL = SNDRV_CARD_TYPE_SERIAL,
+ SND_CARD_TYPE_AD1848 = SNDRV_CARD_TYPE_AD1848,
+ SND_CARD_TYPE_TRID4DWAVEDX = SNDRV_CARD_TYPE_TRID4DWAVEDX,
+ SND_CARD_TYPE_TRID4DWAVENX = SNDRV_CARD_TYPE_TRID4DWAVENX,
+ SND_CARD_TYPE_SGALAXY = SNDRV_CARD_TYPE_SGALAXY,
+ SND_CARD_TYPE_CS46XX = SNDRV_CARD_TYPE_CS46XX,
+ SND_CARD_TYPE_WAVEFRONT = SNDRV_CARD_TYPE_WAVEFRONT,
+ SND_CARD_TYPE_TROPEZ = SNDRV_CARD_TYPE_TROPEZ,
+ SND_CARD_TYPE_TROPEZPLUS = SNDRV_CARD_TYPE_TROPEZPLUS,
+ SND_CARD_TYPE_MAUI = SNDRV_CARD_TYPE_MAUI,
+ SND_CARD_TYPE_CMI8330 = SNDRV_CARD_TYPE_CMI8330,
+ SND_CARD_TYPE_DUMMY = SNDRV_CARD_TYPE_DUMMY,
+ SND_CARD_TYPE_ALS100 = SNDRV_CARD_TYPE_ALS100,
+ SND_CARD_TYPE_SHARE = SNDRV_CARD_TYPE_SHARE,
+ SND_CARD_TYPE_SI_7018 = SNDRV_CARD_TYPE_SI_7018,
+ SND_CARD_TYPE_OPTI93X = SNDRV_CARD_TYPE_OPTI93X,
+ SND_CARD_TYPE_MTPAV = SNDRV_CARD_TYPE_MTPAV,
+ SND_CARD_TYPE_VIRMIDI = SNDRV_CARD_TYPE_VIRMIDI,
+ SND_CARD_TYPE_EMU10K1 = SNDRV_CARD_TYPE_EMU10K1,
+ SND_CARD_TYPE_HAMMERFALL = SNDRV_CARD_TYPE_HAMMERFALL,
+ SND_CARD_TYPE_HAMMERFALL_LIGHT = SNDRV_CARD_TYPE_HAMMERFALL_LIGHT,
+ SND_CARD_TYPE_ICE1712 = SNDRV_CARD_TYPE_ICE1712,
+ SND_CARD_TYPE_CMI8338 = SNDRV_CARD_TYPE_CMI8338,
+ SND_CARD_TYPE_CMI8738 = SNDRV_CARD_TYPE_CMI8738,
+ SND_CARD_TYPE_AD1816A = SNDRV_CARD_TYPE_AD1816A,
+ SND_CARD_TYPE_INTEL8X0 = SNDRV_CARD_TYPE_INTEL8X0,
+ SND_CARD_TYPE_ESS_ESOLDM1 = SNDRV_CARD_TYPE_ESS_ESOLDM1,
+ SND_CARD_TYPE_ESS_ES1968 = SNDRV_CARD_TYPE_ESS_ES1968,
+ SND_CARD_TYPE_ESS_ES1978 = SNDRV_CARD_TYPE_ESS_ES1978,
+ SND_CARD_TYPE_DIGI96 = SNDRV_CARD_TYPE_DIGI96,
+ SND_CARD_TYPE_VIA82C686A = SNDRV_CARD_TYPE_VIA82C686A,
+ SND_CARD_TYPE_FM801 = SNDRV_CARD_TYPE_FM801,
+ SND_CARD_TYPE_AZT2320 = SNDRV_CARD_TYPE_AZT2320,
+ SND_CARD_TYPE_PRODIF_PLUS = SNDRV_CARD_TYPE_PRODIF_PLUS,
+ SND_CARD_TYPE_YMFPCI = SNDRV_CARD_TYPE_YMFPCI,
+ SND_CARD_TYPE_CS4281 = SNDRV_CARD_TYPE_CS4281,
+ SND_CARD_TYPE_MPU401_UART = SNDRV_CARD_TYPE_MPU401_UART,
+ SND_CARD_TYPE_ALS4000 = SNDRV_CARD_TYPE_ALS4000,
+ SND_CARD_TYPE_ALLEGRO_1 = SNDRV_CARD_TYPE_ALLEGRO_1,
+ SND_CARD_TYPE_ALLEGRO = SNDRV_CARD_TYPE_ALLEGRO,
+ SND_CARD_TYPE_MAESTRO3 = SNDRV_CARD_TYPE_MAESTRO3,
+ SND_CARD_TYPE_AWACS = SNDRV_CARD_TYPE_AWACS,
+ SND_CARD_TYPE_NM256AV = SNDRV_CARD_TYPE_NM256AV,
+ SND_CARD_TYPE_NM256ZX = SNDRV_CARD_TYPE_NM256ZX,
+ SND_CARD_TYPE_VIA8233 = SNDRV_CARD_TYPE_VIA8233,
+ SND_CARD_TYPE_LAST = SNDRV_CARD_TYPE_LAST,
+} snd_card_type_t;
+
+/** CTL element type */
+typedef enum _snd_ctl_elem_type {
+ /** Invalid type */
+ SND_CTL_ELEM_TYPE_NONE = SNDRV_CTL_ELEM_TYPE_NONE,
+ /** Boolean contents */
+ SND_CTL_ELEM_TYPE_BOOLEAN = SNDRV_CTL_ELEM_TYPE_BOOLEAN,
+ /** Integer contents */
+ SND_CTL_ELEM_TYPE_INTEGER = SNDRV_CTL_ELEM_TYPE_INTEGER,
+ /** Enumerated contents */
+ SND_CTL_ELEM_TYPE_ENUMERATED = SNDRV_CTL_ELEM_TYPE_ENUMERATED,
+ /** Bytes contents */
+ SND_CTL_ELEM_TYPE_BYTES = SNDRV_CTL_ELEM_TYPE_BYTES,
+ /** IEC958 (S/PDIF) setting content */
+ SND_CTL_ELEM_TYPE_IEC958 = SNDRV_CTL_ELEM_TYPE_IEC958,
+ SND_CTL_ELEM_TYPE_LAST = SNDRV_CTL_ELEM_TYPE_LAST,
+} snd_ctl_elem_type_t;
+
+/** CTL related interface */
+typedef enum _snd_ctl_elem_iface {
+ /** Card level */
+ SND_CTL_ELEM_IFACE_CARD = SNDRV_CTL_ELEM_IFACE_CARD,
+ /** Hardware dependent device */
+ SND_CTL_ELEM_IFACE_HWDEP = SNDRV_CTL_ELEM_IFACE_HWDEP,
+ /** Mixer */
+ SND_CTL_ELEM_IFACE_MIXER = SNDRV_CTL_ELEM_IFACE_MIXER,
+ /** PCM */
+ SND_CTL_ELEM_IFACE_PCM = SNDRV_CTL_ELEM_IFACE_PCM,
+ /** RawMidi */
+ SND_CTL_ELEM_IFACE_RAWMIDI = SNDRV_CTL_ELEM_IFACE_RAWMIDI,
+ /** Timer */
+ SND_CTL_ELEM_IFACE_TIMER = SNDRV_CTL_ELEM_IFACE_TIMER,
+ /** Sequencer */
+ SND_CTL_ELEM_IFACE_SEQUENCER = SNDRV_CTL_ELEM_IFACE_SEQUENCER,
+ SND_CTL_ELEM_IFACE_LAST = SNDRV_CTL_ELEM_IFACE_LAST,
+} snd_ctl_elem_iface_t;
-#define SND_CARD_TYPE_GUS_CLASSIC ((snd_card_type_t) SNDRV_CARD_TYPE_GUS_CLASSIC)
-#define SND_CARD_TYPE_GUS_EXTREME ((snd_card_type_t) SNDRV_CARD_TYPE_GUS_EXTREME)
-#define SND_CARD_TYPE_GUS_ACE ((snd_card_type_t) SNDRV_CARD_TYPE_GUS_ACE)
-#define SND_CARD_TYPE_GUS_MAX ((snd_card_type_t) SNDRV_CARD_TYPE_GUS_MAX)
-#define SND_CARD_TYPE_AMD_INTERWAVE ((snd_card_type_t) SNDRV_CARD_TYPE_AMD_INTERWAVE)
-#define SND_CARD_TYPE_SB_10 ((snd_card_type_t) SNDRV_CARD_TYPE_SB_10)
-#define SND_CARD_TYPE_SB_20 ((snd_card_type_t) SNDRV_CARD_TYPE_SB_20)
-#define SND_CARD_TYPE_SB_PRO ((snd_card_type_t) SNDRV_CARD_TYPE_SB_PRO)
-#define SND_CARD_TYPE_SB_16 ((snd_card_type_t) SNDRV_CARD_TYPE_SB_16)
-#define SND_CARD_TYPE_SB_AWE ((snd_card_type_t) SNDRV_CARD_TYPE_SB_AWE)
-#define SND_CARD_TYPE_ESS_ES1688 ((snd_card_type_t) SNDRV_CARD_TYPE_ESS_ES1688)
-#define SND_CARD_TYPE_OPL3_SA2 ((snd_card_type_t) SNDRV_CARD_TYPE_OPL3_SA2)
-#define SND_CARD_TYPE_MOZART ((snd_card_type_t) SNDRV_CARD_TYPE_MOZART)
-#define SND_CARD_TYPE_S3_SONICVIBES ((snd_card_type_t) SNDRV_CARD_TYPE_S3_SONICVIBES)
-#define SND_CARD_TYPE_ENS1370 ((snd_card_type_t) SNDRV_CARD_TYPE_ENS1370)
-#define SND_CARD_TYPE_ENS1371 ((snd_card_type_t) SNDRV_CARD_TYPE_ENS1371)
-#define SND_CARD_TYPE_CS4232 ((snd_card_type_t) SNDRV_CARD_TYPE_CS4232)
-#define SND_CARD_TYPE_CS4236 ((snd_card_type_t) SNDRV_CARD_TYPE_CS4236)
-#define SND_CARD_TYPE_AMD_INTERWAVE_STB ((snd_card_type_t) SNDRV_CARD_TYPE_AMD_INTERWAVE_STB)
-#define SND_CARD_TYPE_ESS_ES1938 ((snd_card_type_t) SNDRV_CARD_TYPE_ESS_ES1938)
-#define SND_CARD_TYPE_ESS_ES18XX ((snd_card_type_t) SNDRV_CARD_TYPE_ESS_ES18XX)
-#define SND_CARD_TYPE_CS4231 ((snd_card_type_t) SNDRV_CARD_TYPE_CS4231)
-#define SND_CARD_TYPE_OPTI92X ((snd_card_type_t) SNDRV_CARD_TYPE_OPTI92X)
-#define SND_CARD_TYPE_SERIAL ((snd_card_type_t) SNDRV_CARD_TYPE_SERIAL)
-#define SND_CARD_TYPE_AD1848 ((snd_card_type_t) SNDRV_CARD_TYPE_AD1848)
-#define SND_CARD_TYPE_TRID4DWAVEDX ((snd_card_type_t) SNDRV_CARD_TYPE_TRID4DWAVEDX)
-#define SND_CARD_TYPE_TRID4DWAVENX ((snd_card_type_t) SNDRV_CARD_TYPE_TRID4DWAVENX)
-#define SND_CARD_TYPE_SGALAXY ((snd_card_type_t) SNDRV_CARD_TYPE_SGALAXY)
-#define SND_CARD_TYPE_CS46XX ((snd_card_type_t) SNDRV_CARD_TYPE_CS46XX)
-#define SND_CARD_TYPE_WAVEFRONT ((snd_card_type_t) SNDRV_CARD_TYPE_WAVEFRONT)
-#define SND_CARD_TYPE_TROPEZ ((snd_card_type_t) SNDRV_CARD_TYPE_TROPEZ)
-#define SND_CARD_TYPE_TROPEZPLUS ((snd_card_type_t) SNDRV_CARD_TYPE_TROPEZPLUS)
-#define SND_CARD_TYPE_MAUI ((snd_card_type_t) SNDRV_CARD_TYPE_MAUI)
-#define SND_CARD_TYPE_CMI8330 ((snd_card_type_t) SNDRV_CARD_TYPE_CMI8330)
-#define SND_CARD_TYPE_DUMMY ((snd_card_type_t) SNDRV_CARD_TYPE_DUMMY)
-#define SND_CARD_TYPE_ALS100 ((snd_card_type_t) SNDRV_CARD_TYPE_ALS100)
-#define SND_CARD_TYPE_SHARE ((snd_card_type_t) SNDRV_CARD_TYPE_SHARE)
-#define SND_CARD_TYPE_SI_7018 ((snd_card_type_t) SNDRV_CARD_TYPE_SI_7018)
-#define SND_CARD_TYPE_OPTI93X ((snd_card_type_t) SNDRV_CARD_TYPE_OPTI93X)
-#define SND_CARD_TYPE_MTPAV ((snd_card_type_t) SNDRV_CARD_TYPE_MTPAV)
-#define SND_CARD_TYPE_VIRMIDI ((snd_card_type_t) SNDRV_CARD_TYPE_VIRMIDI)
-#define SND_CARD_TYPE_EMU10K1 ((snd_card_type_t) SNDRV_CARD_TYPE_EMU10K1)
-#define SND_CARD_TYPE_HAMMERFALL ((snd_card_type_t) SNDRV_CARD_TYPE_HAMMERFALL)
-#define SND_CARD_TYPE_HAMMERFALL_LIGHT ((snd_card_type_t) SNDRV_CARD_TYPE_HAMMERFALL_LIGHT)
-#define SND_CARD_TYPE_ICE1712 ((snd_card_type_t) SNDRV_CARD_TYPE_ICE1712)
-#define SND_CARD_TYPE_CMI8338 ((snd_card_type_t) SNDRV_CARD_TYPE_CMI8338)
-#define SND_CARD_TYPE_CMI8738 ((snd_card_type_t) SNDRV_CARD_TYPE_CMI8738)
-#define SND_CARD_TYPE_AD1816A ((snd_card_type_t) SNDRV_CARD_TYPE_AD1816A)
-#define SND_CARD_TYPE_INTEL8X0 ((snd_card_type_t) SNDRV_CARD_TYPE_INTEL8X0)
-#define SND_CARD_TYPE_ESS_ESOLDM1 ((snd_card_type_t) SNDRV_CARD_TYPE_ESS_ESOLDM1)
-#define SND_CARD_TYPE_ESS_ES1968 ((snd_card_type_t) SNDRV_CARD_TYPE_ESS_ES1968)
-#define SND_CARD_TYPE_ESS_ES1978 ((snd_card_type_t) SNDRV_CARD_TYPE_ESS_ES1978)
-#define SND_CARD_TYPE_DIGI96 ((snd_card_type_t) SNDRV_CARD_TYPE_DIGI96)
-#define SND_CARD_TYPE_VIA82C686A ((snd_card_type_t) SNDRV_CARD_TYPE_VIA82C686A)
-#define SND_CARD_TYPE_FM801 ((snd_card_type_t) SNDRV_CARD_TYPE_FM801)
-#define SND_CARD_TYPE_AZT2320 ((snd_card_type_t) SNDRV_CARD_TYPE_AZT2320)
-#define SND_CARD_TYPE_PRODIF_PLUS ((snd_card_type_t) SNDRV_CARD_TYPE_PRODIF_PLUS)
-#define SND_CARD_TYPE_YMFPCI ((snd_card_type_t) SNDRV_CARD_TYPE_YMFPCI)
-#define SND_CARD_TYPE_CS4281 ((snd_card_type_t) SNDRV_CARD_TYPE_CS4281)
-#define SND_CARD_TYPE_MPU401_UART ((snd_card_type_t) SNDRV_CARD_TYPE_MPU401_UART)
-#define SND_CARD_TYPE_ALS4000 ((snd_card_type_t) SNDRV_CARD_TYPE_ALS4000)
-#define SND_CARD_TYPE_ALLEGRO_1 ((snd_card_type_t) SNDRV_CARD_TYPE_ALLEGRO_1)
-#define SND_CARD_TYPE_ALLEGRO ((snd_card_type_t) SNDRV_CARD_TYPE_ALLEGRO)
-#define SND_CARD_TYPE_MAESTRO3 ((snd_card_type_t) SNDRV_CARD_TYPE_MAESTRO3)
-#define SND_CARD_TYPE_AWACS ((snd_card_type_t) SNDRV_CARD_TYPE_AWACS)
-#define SND_CARD_TYPE_NM256AV ((snd_card_type_t) SNDRV_CARD_TYPE_NM256AV)
-#define SND_CARD_TYPE_NM256ZX ((snd_card_type_t) SNDRV_CARD_TYPE_NM256ZX)
-#define SND_CARD_TYPE_VIA8233 ((snd_card_type_t) SNDRV_CARD_TYPE_VIA8233)
-#define SND_CARD_TYPE_LAST ((snd_card_type_t) SNDRV_CARD_TYPE_LAST)
-
-#define SND_CTL_ELEM_TYPE_NONE ((snd_ctl_elem_type_t) SNDRV_CTL_ELEM_TYPE_NONE)
-#define SND_CTL_ELEM_TYPE_BOOLEAN ((snd_ctl_elem_type_t) SNDRV_CTL_ELEM_TYPE_BOOLEAN)
-#define SND_CTL_ELEM_TYPE_INTEGER ((snd_ctl_elem_type_t) SNDRV_CTL_ELEM_TYPE_INTEGER)
-#define SND_CTL_ELEM_TYPE_ENUMERATED ((snd_ctl_elem_type_t) SNDRV_CTL_ELEM_TYPE_ENUMERATED)
-#define SND_CTL_ELEM_TYPE_BYTES ((snd_ctl_elem_type_t) SNDRV_CTL_ELEM_TYPE_BYTES)
-#define SND_CTL_ELEM_TYPE_IEC958 ((snd_ctl_elem_type_t) SNDRV_CTL_ELEM_TYPE_IEC958)
-#define SND_CTL_ELEM_TYPE_LAST ((snd_ctl_elem_type_t) SNDRV_CTL_ELEM_TYPE_LAST)
-
-#define SND_CTL_ELEM_IFACE_CARD ((snd_ctl_elem_iface_t) SNDRV_CTL_ELEM_IFACE_CARD)
-#define SND_CTL_ELEM_IFACE_HWDEP ((snd_ctl_elem_iface_t) SNDRV_CTL_ELEM_IFACE_HWDEP)
-#define SND_CTL_ELEM_IFACE_MIXER ((snd_ctl_elem_iface_t) SNDRV_CTL_ELEM_IFACE_MIXER)
-#define SND_CTL_ELEM_IFACE_PCM ((snd_ctl_elem_iface_t) SNDRV_CTL_ELEM_IFACE_PCM)
-#define SND_CTL_ELEM_IFACE_RAWMIDI ((snd_ctl_elem_iface_t) SNDRV_CTL_ELEM_IFACE_RAWMIDI)
-#define SND_CTL_ELEM_IFACE_TIMER ((snd_ctl_elem_iface_t) SNDRV_CTL_ELEM_IFACE_TIMER)
-#define SND_CTL_ELEM_IFACE_SEQUENCER ((snd_ctl_elem_iface_t) SNDRV_CTL_ELEM_IFACE_SEQUENCER)
-#define SND_CTL_ELEM_IFACE_LAST ((snd_ctl_elem_iface_t) SNDRV_CTL_ELEM_IFACE_LAST)
-
-#define SND_CTL_EVENT_ELEM ((snd_ctl_event_type_t) SNDRV_CTL_EVENT_ELEM)
-#define SND_CTL_EVENT_LAST ((snd_ctl_event_type_t) SNDRV_CTL_EVENT_LAST)
+/** Event class */
+typedef enum _snd_ctl_event_type {
+ /** Elements related event */
+ SND_CTL_EVENT_ELEM = SNDRV_CTL_EVENT_ELEM,
+ SND_CTL_EVENT_LAST = SNDRV_CTL_EVENT_LAST,
+}snd_ctl_event_type_t;
+/** Element has been removed (Warning: test this first and if set don't
+ * test the other masks) \hideinitializer */
+#define SND_CTL_EVENT_MASK_REMOVE SNDRV_CTL_EVENT_MASK_REMOVE
+/** Element has been added \hideinitializer */
#define SND_CTL_EVENT_MASK_ADD SNDRV_CTL_EVENT_MASK_ADD
+/** Element info has been changed \hideinitializer */
#define SND_CTL_EVENT_MASK_INFO SNDRV_CTL_EVENT_MASK_INFO
+/** Element value has been changed \hideinitializer */
#define SND_CTL_EVENT_MASK_VALUE SNDRV_CTL_EVENT_MASK_VALUE
-#define SND_CTL_EVENT_MASK_REMOVE SNDRV_CTL_EVENT_MASK_REMOVE
#define SND_CTL_NAME_IEC958 SNDRV_CTL_NAME_IEC958
-enum _snd_ctl_type {
+/** CTL type */
+typedef enum _snd_ctl_type {
+ /** Kernel level CTL */
SND_CTL_TYPE_HW,
+ /** Shared memory client CTL */
SND_CTL_TYPE_SHM,
+ /** INET client CTL (not yet implemented) */
SND_CTL_TYPE_INET
-};
+} snd_ctl_type_t;
-#ifdef SND_ENUM_TYPECHECK
-typedef struct __snd_ctl_type *snd_ctl_type_t;
-#else
-typedef enum _snd_ctl_type snd_ctl_type_t;
-#endif
+/** Non blocking mode \hideinitializer */
+#define SND_CTL_NONBLOCK 0x0001
-#define SND_CTL_TYPE_HW ((snd_ctl_type_t) SND_CTL_TYPE_HW)
-#define SND_CTL_TYPE_SHM ((snd_ctl_type_t) SND_CTL_TYPE_SHM)
-#define SND_CTL_TYPE_INET ((snd_ctl_type_t) SND_CTL_TYPE_INET)
+/** Async notification \hideinitializer */
+#define SND_CTL_ASYNC 0x0002
+/** CTL handle */
typedef struct _snd_ctl snd_ctl_t;
#ifdef __cplusplus
int snd_defaults_rawmidi_device(void);
snd_ctl_type_t snd_ctl_type(snd_ctl_t *ctl);
-int snd_ctl_open(snd_ctl_t **ctl, const char *name);
+int snd_ctl_open(snd_ctl_t **ctl, const char *name, int mode);
int snd_ctl_close(snd_ctl_t *ctl);
int snd_ctl_nonblock(snd_ctl_t *ctl, int nonblock);
int snd_ctl_async(snd_ctl_t *ctl, int sig, pid_t pid);
typedef int (*snd_hctl_elem_callback_t)(snd_hctl_elem_t *elem,
unsigned int mask);
-int snd_hctl_open(snd_hctl_t **hctl, const char *name);
+int snd_hctl_open(snd_hctl_t **hctl, const char *name, int mode);
int snd_hctl_close(snd_hctl_t *hctl);
int snd_hctl_nonblock(snd_hctl_t *hctl, int nonblock);
int snd_hctl_async(snd_hctl_t *hctl, int sig, pid_t pid);
extern "C" {
#endif
-int snd_mixer_open(snd_mixer_t **mixer);
+int snd_mixer_open(snd_mixer_t **mixer, int mode);
int snd_mixer_close(snd_mixer_t *mixer);
int snd_mixer_info(snd_mixer_t *mixer, snd_mixer_info_t *info);
snd_mixer_elem_t *snd_mixer_first_elem(snd_mixer_t *mixer);
extern "C" {
#endif
-int snd_timer_open(snd_timer_t **handle);
+int snd_timer_open(snd_timer_t **handle, int mode);
int snd_timer_close(snd_timer_t *handle);
int snd_timer_poll_descriptors_count(snd_timer_t *handle);
int snd_timer_poll_descriptors(snd_timer_t *handle, struct pollfd *pfds, unsigned int space);
for (card = 0; card < 32; card++) {
if (snd_card_load(card) < 0)
continue;
- if (snd_ctl_hw_open(&handle, NULL, card) < 0)
+ if (snd_ctl_hw_open(&handle, NULL, card, 0) < 0)
continue;
if (snd_ctl_card_info(handle, &info) < 0) {
snd_ctl_close(handle);
if (name == NULL)
return -EINVAL;
- if ((err = snd_ctl_hw_open(&handle, NULL, card)) < 0)
+ if ((err = snd_ctl_hw_open(&handle, NULL, card, 0)) < 0)
return err;
if ((err = snd_ctl_card_info(handle, &info)) < 0) {
snd_ctl_close(handle);
if (name == NULL)
return -EINVAL;
- if ((err = snd_ctl_hw_open(&handle, NULL, card)) < 0)
+ if ((err = snd_ctl_hw_open(&handle, NULL, card, 0)) < 0)
return err;
if ((err = snd_ctl_card_info(handle, &info)) < 0) {
snd_ctl_close(handle);
+/**
+ * \file control/control.c
+ * \author Abramo Bagnara <abramo@alsa-project.org>
+ * \date 2000
+ *
+ * CTL interface is designed to access primitive controls.
+ */
/*
* Control Interface - main file
* Copyright (c) 2000 by Abramo Bagnara <abramo@alsa-project.org>
*
*/
+#ifndef DOC_HIDDEN
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <fcntl.h>
#include <dlfcn.h>
+#include <signal.h>
#include <sys/poll.h>
#include "control_local.h"
+#endif
+/**
+ * \brief get identifier of CTL handle
+ * \param ctl CTL handle
+ * \return ascii identifier of CTL handle
+ *
+ * Returns the ASCII identifier of given CTL handle. It's the same
+ * identifier specified in snd_ctl_open().
+ */
const char *snd_ctl_name(snd_ctl_t *ctl)
{
assert(ctl);
return ctl->name;
}
+/**
+ * \brief get type of CTL handle
+ * \param ctl CTL handle
+ * \return type of CTL handle
+ *
+ * Returns the type #snd_ctl_type_t of given CTL handle.
+ */
snd_ctl_type_t snd_ctl_type(snd_ctl_t *ctl)
{
assert(ctl);
return ctl->type;
}
+/**
+ * \brief close CTL handle
+ * \param ctl CTL handle
+ * \return 0 on success otherwise a negative error code
+ *
+ * Closes the specified CTL handle and frees all associated
+ * resources.
+ */
int snd_ctl_close(snd_ctl_t *ctl)
{
int res;
return res;
}
+/**
+ * \brief set nonblock mode
+ * \param ctl CTL handle
+ * \param nonblock 0 = block, 1 = nonblock mode
+ * \return 0 on success otherwise a negative error code
+ */
int snd_ctl_nonblock(snd_ctl_t *ctl, int nonblock)
{
int err;
return 0;
}
+/**
+ * \brief set async mode
+ * \param ctl CTL handle
+ * \param sig Signal to raise: < 0 disable, 0 default (SIGIO)
+ * \param pid Process ID to signal: 0 current
+ * \return 0 on success otherwise a negative error code
+ *
+ * A signal is raised when a change happens.
+ */
int snd_ctl_async(snd_ctl_t *ctl, int sig, pid_t pid)
{
+ int err;
assert(ctl);
- return ctl->ops->async(ctl, sig, pid);
-}
-
-int _snd_ctl_poll_descriptor(snd_ctl_t *ctl)
-{
- assert(ctl);
- return ctl->ops->poll_descriptor(ctl);
+ err = ctl->ops->async(ctl, sig, pid);
+ if (err < 0)
+ return err;
+ if (sig)
+ ctl->async_sig = sig;
+ else
+ ctl->async_sig = SIGIO;
+ if (pid)
+ ctl->async_pid = pid;
+ else
+ ctl->async_pid = getpid();
+ return 0;
}
+/**
+ * \brief get count of poll descriptors for CTL handle
+ * \param ctl CTL handle
+ * \return count of poll descriptors
+ */
int snd_ctl_poll_descriptors_count(snd_ctl_t *ctl)
{
assert(ctl);
return 1;
}
+/**
+ * \brief get poll descriptors
+ * \param ctl CTL handle
+ * \param pfds array of poll descriptors
+ * \param space space in the poll descriptor array
+ * \return count of filled descriptors
+ */
int snd_ctl_poll_descriptors(snd_ctl_t *ctl, struct pollfd *pfds, unsigned int space)
{
assert(ctl);
return 0;
}
+/**
+ * \brief Ask to be informed about events (poll, #snd_ctl_async, #snd_ctl_read)
+ * \param ctl CTL handle
+ * \param subscribe 0 = unsubscribe, 1 = subscribe
+ * \return 0 on success otherwise a negative error code
+ */
int snd_ctl_subscribe_events(snd_ctl_t *ctl, int subscribe)
{
assert(ctl);
return ctl->ops->subscribe_events(ctl, subscribe);
}
+
+/**
+ * \brief Get card related information
+ * \param ctl CTL handle
+ * \param info Card info pointer
+ * \return 0 on success otherwise a negative error code
+ */
int snd_ctl_card_info(snd_ctl_t *ctl, snd_ctl_card_info_t *info)
{
assert(ctl && info);
return ctl->ops->card_info(ctl, info);
}
+/**
+ * \brief Get a list of element identificators
+ * \param ctl CTL handle
+ * \param list CTL element identificators list pointer
+ * \return 0 on success otherwise a negative error code
+ */
int snd_ctl_elem_list(snd_ctl_t *ctl, snd_ctl_elem_list_t *list)
{
assert(ctl && list);
return ctl->ops->element_list(ctl, list);
}
+/**
+ * \brief Get CTL element information
+ * \param ctl CTL handle
+ * \param info CTL element id/information pointer
+ * \return 0 on success otherwise a negative error code
+ */
int snd_ctl_elem_info(snd_ctl_t *ctl, snd_ctl_elem_info_t *info)
{
assert(ctl && info && (info->id.name[0] || info->id.numid));
return ctl->ops->element_info(ctl, info);
}
+/**
+ * \brief Get CTL element value
+ * \param ctl CTL handle
+ * \param control CTL element id/value pointer
+ * \return 0 on success otherwise a negative error code
+ */
int snd_ctl_elem_read(snd_ctl_t *ctl, snd_ctl_elem_value_t *control)
{
assert(ctl && control && (control->id.name[0] || control->id.numid));
return ctl->ops->element_read(ctl, control);
}
+/**
+ * \brief Set CTL element value
+ * \param ctl CTL handle
+ * \param control CTL element id/value pointer
+ * \return 0 on success otherwise a negative error code
+ */
int snd_ctl_elem_write(snd_ctl_t *ctl, snd_ctl_elem_value_t *control)
{
assert(ctl && control && (control->id.name[0] || control->id.numid));
return ctl->ops->element_write(ctl, control);
}
+/**
+ * \brief Get next hardware dependent device number
+ * \param ctl CTL handle
+ * \param device current device on entry and next device on return
+ * \return 0 on success otherwise a negative error code
+ */
int snd_ctl_hwdep_next_device(snd_ctl_t *ctl, int *device)
{
assert(ctl && device);
return ctl->ops->hwdep_next_device(ctl, device);
}
+/**
+ * \brief Get info about a hardware dependent device
+ * \param ctl CTL handle
+ * \param info Hardware dependent device id/info pointer
+ * \return 0 on success otherwise a negative error code
+ */
int snd_ctl_hwdep_info(snd_ctl_t *ctl, snd_hwdep_info_t * info)
{
assert(ctl && info);
return ctl->ops->hwdep_info(ctl, info);
}
+/**
+ * \brief Get next PCM device number
+ * \param ctl CTL handle
+ * \param device current device on entry and next device on return
+ * \return 0 on success otherwise a negative error code
+ */
int snd_ctl_pcm_next_device(snd_ctl_t *ctl, int * device)
{
assert(ctl && device);
return ctl->ops->pcm_next_device(ctl, device);
}
+/**
+ * \brief Get info about a PCM device
+ * \param ctl CTL handle
+ * \param info PCM device id/info pointer
+ * \return 0 on success otherwise a negative error code
+ */
int snd_ctl_pcm_info(snd_ctl_t *ctl, snd_pcm_info_t * info)
{
assert(ctl && info);
return ctl->ops->pcm_info(ctl, info);
}
+/**
+ * \brief Set preferred PCM subdevice number of successive PCM open
+ * \param ctl CTL handle
+ * \param subdev Preferred PCM subdevice number
+ * \return 0 on success otherwise a negative error code
+ */
int snd_ctl_pcm_prefer_subdevice(snd_ctl_t *ctl, int subdev)
{
assert(ctl);
return ctl->ops->pcm_prefer_subdevice(ctl, subdev);
}
+/**
+ * \brief Get next RawMidi device number
+ * \param ctl CTL handle
+ * \param device current device on entry and next device on return
+ * \return 0 on success otherwise a negative error code
+ */
int snd_ctl_rawmidi_next_device(snd_ctl_t *ctl, int * device)
{
assert(ctl && device);
return ctl->ops->rawmidi_next_device(ctl, device);
}
+/**
+ * \brief Get info about a RawMidi device
+ * \param ctl CTL handle
+ * \param info RawMidi device id/info pointer
+ * \return 0 on success otherwise a negative error code
+ */
int snd_ctl_rawmidi_info(snd_ctl_t *ctl, snd_rawmidi_info_t * info)
{
assert(ctl && info);
return ctl->ops->rawmidi_info(ctl, info);
}
+/**
+ * \brief Set preferred RawMidi subdevice number of successive RawMidi open
+ * \param ctl CTL handle
+ * \param subdev Preferred RawMidi subdevice number
+ * \return 0 on success otherwise a negative error code
+ */
int snd_ctl_rawmidi_prefer_subdevice(snd_ctl_t *ctl, int subdev)
{
assert(ctl);
return ctl->ops->rawmidi_prefer_subdevice(ctl, subdev);
}
+
+/**
+ * \brief Read an event
+ * \param ctl CTL handle
+ * \param event Event pointer
+ * \return number of events read otherwise a negative error code on failure
+ */
int snd_ctl_read(snd_ctl_t *ctl, snd_ctl_event_t *event)
{
assert(ctl && event);
return ctl->ops->read(ctl, event);
}
+/**
+ * \brief Wait for a CTL to become ready (i.e. at least one event pending)
+ * \param ctl CTL handle
+ * \param timeout maximum time in milliseconds to wait
+ * \return 0 otherwise a negative error code on failure
+ */
int snd_ctl_wait(snd_ctl_t *ctl, int timeout)
{
struct pollfd pfd;
return 0;
}
-int snd_ctl_open(snd_ctl_t **ctlp, const char *name)
+/**
+ * \brief Opens a CTL
+ * \param ctlp Returned CTL handle
+ * \param name ASCII identifier of the CTL handle
+ * \param mode Open mode (see #SND_CTL_NONBLOCK, #SND_CTL_ASYNC)
+ * \return 0 on success otherwise a negative error code
+ */
+int snd_ctl_open(snd_ctl_t **ctlp, const char *name, int mode)
{
const char *str;
char buf[256];
snd_config_t *ctl_conf, *conf, *type_conf;
snd_config_iterator_t i, next;
const char *lib = NULL, *open = NULL;
- int (*open_func)(snd_ctl_t **ctlp, const char *name, snd_config_t *conf);
+ int (*open_func)(snd_ctl_t **ctlp, const char *name, snd_config_t *conf, int mode);
void *h;
const char *name1;
assert(ctlp && name);
char socket[256], sname[256];
err = sscanf(name1, "hw:%d", &card);
if (err == 1)
- return snd_ctl_hw_open(ctlp, name, card);
+ return snd_ctl_hw_open(ctlp, name, card, mode);
err = sscanf(name1, "shm:%256[^,],%256[^,]", socket, sname);
if (err == 2)
- return snd_ctl_shm_open(ctlp, name, socket, sname);
+ return snd_ctl_shm_open(ctlp, name, socket, sname, mode);
SNDERR("Unknown ctl %s", name1);
return -ENOENT;
}
dlclose(h);
return -ENXIO;
}
- return open_func(ctlp, name, ctl_conf);
+ return open_func(ctlp, name, ctl_conf, mode);
}
+/**
+ * \brief Set CTL element #SND_CTL_ELEM_TYPE_BYTES value
+ * \param ctl CTL handle
+ * \param data Bytes value
+ * \param size Size in bytes
+ */
void snd_ctl_elem_set_bytes(snd_ctl_elem_value_t *obj, void *data, size_t size)
{
assert(obj);
- assert(size <= sizeof(obj->value.bytes.data));
+ if (size >= sizeof(obj->value.bytes.data)) {
+ assert(0);
+ return;
+ }
memcpy(obj->value.bytes.data, data, size);
}
+#ifndef DOC_HIDDEN
#define TYPE(v) [SND_CTL_ELEM_TYPE_##v] = #v
#define IFACE(v) [SND_CTL_ELEM_IFACE_##v] = #v
#define EVENT(v) [SND_CTL_EVENT_##v] = #v
-const char *snd_ctl_elem_type_names[] = {
+static const char *snd_ctl_elem_type_names[] = {
TYPE(NONE),
TYPE(BOOLEAN),
TYPE(INTEGER),
TYPE(IEC958),
};
-const char *snd_ctl_elem_iface_names[] = {
+static const char *snd_ctl_elem_iface_names[] = {
IFACE(CARD),
IFACE(HWDEP),
IFACE(MIXER),
IFACE(SEQUENCER),
};
-const char *snd_ctl_event_type_names[] = {
+static const char *snd_ctl_event_type_names[] = {
EVENT(ELEM),
};
+#endif
+/**
+ * \brief get name of a CTL element type
+ * \param type CTL element type
+ * \return ascii name of CTL element type
+ */
const char *snd_ctl_elem_type_name(snd_ctl_elem_type_t type)
{
assert(type <= SND_CTL_ELEM_TYPE_LAST);
return snd_ctl_elem_type_names[snd_enum_to_int(type)];
}
+/**
+ * \brief get name of a CTL element related interface
+ * \param iface CTL element related interface
+ * \return ascii name of CTL element related interface
+ */
const char *snd_ctl_elem_iface_name(snd_ctl_elem_iface_t iface)
{
assert(iface <= SND_CTL_ELEM_IFACE_LAST);
return snd_ctl_elem_iface_names[snd_enum_to_int(iface)];
}
+/**
+ * \brief get name of a CTL event type
+ * \param type CTL event type
+ * \return ascii name of CTL event type
+ */
const char *snd_ctl_event_type_name(snd_ctl_event_type_t type)
{
assert(type <= SND_CTL_EVENT_LAST);
return snd_ctl_event_type_names[snd_enum_to_int(type)];
}
+/**
+ * \brief allocate space for CTL element identificators list
+ * \param obj CTL element identificators list
+ * \param entries Entries to allocate
+ * \return 0 on success otherwise a negative error code
+ */
int snd_ctl_elem_list_alloc_space(snd_ctl_elem_list_t *obj, unsigned int entries)
{
if (obj->pids)
return 0;
}
+/**
+ * \brief free previously allocated space for CTL element identificators list
+ * \param obj CTL element identificators list
+ */
void snd_ctl_elem_list_free_space(snd_ctl_elem_list_t *obj)
{
free(obj->pids);
obj->pids = NULL;
}
+/**
+ * \brief Get event mask for an element related event
+ * \param obj CTL event
+ * \return event mask for element related event
+ */
unsigned int snd_ctl_event_elem_get_mask(const snd_ctl_event_t *obj)
{
assert(obj);
return obj->data.elem.mask;
}
+/**
+ * \brief Get element numeric identificator for an element related event
+ * \param obj CTL event
+ * \return element numeric identificator for element related event
+ */
unsigned int snd_ctl_event_elem_get_numid(const snd_ctl_event_t *obj)
{
assert(obj);
return obj->data.elem.id.numid;
}
+/**
+ * \brief Get CTL element identificator for an element related event
+ * \param obj CTL event
+ * \param ptr Pointer to returned CTL element identificator
+ */
void snd_ctl_event_elem_get_id(const snd_ctl_event_t *obj, snd_ctl_elem_id_t *ptr)
{
assert(obj && ptr);
*ptr = obj->data.elem.id;
}
+/**
+ * \brief Get interface part of CTL element identificator for an element related event
+ * \param obj CTL event
+ * \return interface part of element identificator
+ */
snd_ctl_elem_iface_t snd_ctl_event_elem_get_interface(const snd_ctl_event_t *obj)
{
assert(obj);
return snd_int_to_enum(obj->data.elem.id.iface);
}
+/**
+ * \brief Get device part of CTL element identificator for an element related event
+ * \param obj CTL event
+ * \return device part of element identificator
+ */
unsigned int snd_ctl_event_elem_get_device(const snd_ctl_event_t *obj)
{
assert(obj);
return obj->data.elem.id.device;
}
+/**
+ * \brief Get subdevice part of CTL element identificator for an element related event
+ * \param obj CTL event
+ * \return subdevice part of element identificator
+ */
unsigned int snd_ctl_event_elem_get_subdevice(const snd_ctl_event_t *obj)
{
assert(obj);
return obj->data.elem.id.subdevice;
}
+/**
+ * \brief Get name part of CTL element identificator for an element related event
+ * \param obj CTL event
+ * \return name part of element identificator
+ */
const char *snd_ctl_event_elem_get_name(const snd_ctl_event_t *obj)
{
assert(obj);
return obj->data.elem.id.name;
}
+/**
+ * \brief Get index part of CTL element identificator for an element related event
+ * \param obj CTL event
+ * \return index part of element identificator
+ */
unsigned int snd_ctl_event_elem_get_index(const snd_ctl_event_t *obj)
{
assert(obj);
return obj->data.elem.id.index;
}
+#ifndef DOC_HIDDEN
+int _snd_ctl_poll_descriptor(snd_ctl_t *ctl)
+{
+ assert(ctl);
+ return ctl->ops->poll_descriptor(ctl);
+}
+#endif
read: snd_ctl_hw_read,
};
-int snd_ctl_hw_open(snd_ctl_t **handle, const char *name, int card)
+int snd_ctl_hw_open(snd_ctl_t **handle, const char *name, int card, int mode)
{
int fd, ver;
char filename[32];
+ int fmode;
snd_ctl_t *ctl;
snd_ctl_hw_t *hw;
assert(card >= 0 && card < 32);
sprintf(filename, SNDRV_FILE_CONTROL, card);
- if ((fd = open(filename, O_RDWR)) < 0) {
+ fmode = O_RDWR;
+ if (mode & SND_CTL_NONBLOCK)
+ fmode |= O_NONBLOCK;
+ if (mode & SND_CTL_ASYNC)
+ fmode |= O_ASYNC;
+ if ((fd = open(filename, fmode)) < 0) {
snd_card_load(card);
if ((fd = open(filename, O_RDWR)) < 0)
return -errno;
}
if (card < 0)
return -EINVAL;
- return snd_ctl_hw_open(handlep, name, card);
+ return snd_ctl_hw_open(handlep, name, card, 0);
}
snd_ctl_ops_t *ops;
void *private_data;
int nonblock;
+ int async_sig;
+ pid_t async_pid;
};
struct _snd_hctl_elem {
int _snd_ctl_poll_descriptor(snd_ctl_t *ctl);
-int snd_ctl_hw_open(snd_ctl_t **handle, const char *name, int card);
-int snd_ctl_shm_open(snd_ctl_t **handlep, const char *name, const char *socket, const char *sname);
+int snd_ctl_hw_open(snd_ctl_t **handle, const char *name, int card, int mode);
+int snd_ctl_shm_open(snd_ctl_t **handlep, const char *name, const char *socket, const char *sname, int mode);
}
#endif
-int snd_ctl_shm_open(snd_ctl_t **handlep, const char *name, const char *socket, const char *sname)
+int snd_ctl_shm_open(snd_ctl_t **handlep, const char *name, const char *socket, const char *sname, int mode)
{
snd_ctl_t *ctl;
snd_ctl_shm_t *shm = NULL;
req->dev_type = SND_DEV_TYPE_CONTROL;
req->transport_type = SND_TRANSPORT_TYPE_SHM;
req->stream = 0;
- req->mode = 0;
+ req->mode = mode;
req->namelen = snamelen;
err = write(sock, req, reqlen);
if (err < 0) {
extern int is_local(struct hostent *hent);
-int _snd_ctl_shm_open(snd_ctl_t **handlep, char *name, snd_config_t *conf)
+int _snd_ctl_shm_open(snd_ctl_t **handlep, char *name, snd_config_t *conf, int mode)
{
snd_config_iterator_t i, next;
const char *server = NULL;
SNDERR("%s is not the local host", host);
return -EINVAL;
}
- return snd_ctl_shm_open(handlep, name, socket, sname);
+ return snd_ctl_shm_open(handlep, name, socket, sname, mode);
}
if (result >= 0)
return result;
sprintf(id, "hw:%i", snd_defaults_pcm_card());
- if (snd_ctl_open(&handle, id) < 0)
+ if (snd_ctl_open(&handle, id, 0) < 0)
return -ENOENT;
result = -1;
if (snd_ctl_pcm_next_device(handle, &result) < 0) {
if (result >= 0)
return result;
sprintf(id, "hw:%i", snd_defaults_rawmidi_card());
- if (snd_ctl_open(&handle, id) < 0)
+ if (snd_ctl_open(&handle, id, 0) < 0)
return -ENOENT;
result = -1;
if (snd_ctl_rawmidi_next_device(handle, &result) < 0) {
static int snd_hctl_compare_default(const snd_hctl_elem_t *c1,
const snd_hctl_elem_t *c2);
-int snd_hctl_open(snd_hctl_t **hctlp, const char *name)
+int snd_hctl_open(snd_hctl_t **hctlp, const char *name, int mode)
{
snd_hctl_t *hctl;
snd_ctl_t *ctl;
assert(hctlp);
*hctlp = NULL;
- if ((err = snd_ctl_open(&ctl, name)) < 0)
+ if ((err = snd_ctl_open(&ctl, name, mode)) < 0)
return err;
if ((hctl = (snd_hctl_t *)calloc(1, sizeof(snd_hctl_t))) == NULL) {
snd_ctl_close(ctl);
/**
* \brief close input handle
* \param input Input handle
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_input_close(snd_input_t *input)
{
* \param input Input handle
* \param format fscanf format
* \param ... other fscanf arguments
- * \return number of input itmes assigned or a negative error code
+ * \return number of input items assigned otherwise a negative error code
*/
int snd_input_scanf(snd_input_t *input, const char *format, ...)
{
const snd_mixer_elem_t *c2);
-int snd_mixer_open(snd_mixer_t **mixerp)
+int snd_mixer_open(snd_mixer_t **mixerp, int mode ATTRIBUTE_UNUSED)
{
snd_mixer_t *mixer;
assert(mixerp);
slave = calloc(1, sizeof(*slave));
if (slave == NULL)
return -ENOMEM;
- err = snd_hctl_open(&hctl, name);
+ err = snd_hctl_open(&hctl, name, 0);
if (err < 0) {
free(slave);
return err;
/**
* \brief close output handle
* \param output Output handle
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_output_close(snd_output_t *output)
{
* \param output Output handle
* \param format fprintf format
* \param ... other fprintf arguments
- * \return number of characters written or a negative error code
+ * \return number of characters written otherwise a negative error code
*/
int snd_output_printf(snd_output_t *output, const char *format, ...)
{
* \return ascii identifier of PCM handle
*
* Returns the ASCII identifier of given PCM handle. It's the same
- * identifier as for snd_pcm_open().
+ * identifier specified in snd_pcm_open().
*/
const char *snd_pcm_name(snd_pcm_t *pcm)
{
/**
* \brief close PCM handle
* \param pcm PCM handle
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*
* Closes the specified PCM handle and frees all associated
* resources.
* \brief set nonblock mode
* \param pcm PCM handle
* \param nonblock 0 = block, 1 = nonblock mode
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_pcm_nonblock(snd_pcm_t *pcm, int nonblock)
{
* \param pcm PCM handle
* \param sig Signal to raise: < 0 disable, 0 default (SIGIO)
* \param pid Process ID to signal: 0 current
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*
* A signal is raised every period.
*/
* \brief Obtain general (static) information for PCM handle
* \param pcm PCM handle
* \param info Information container
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_pcm_info(snd_pcm_t *pcm, snd_pcm_info_t *info)
{
/** \brief Install one PCM hardware configuration choosen from a configuration space and #snd_pcm_prepare it
* \param pcm PCM handle
* \param params Configuration space definition container
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*
* The configuration is choosen fixing single parameters in this order:
* first access, first format, first subformat, min channels, min rate,
/** \brief Remove PCM hardware configuration and free associated resources
* \param pcm PCM handle
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_pcm_hw_free(snd_pcm_t *pcm)
{
/** \brief Install PCM software configuration defined by params
* \param pcm PCM handle
* \param params Configuration container
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_pcm_sw_params(snd_pcm_t *pcm, snd_pcm_sw_params_t *params)
{
* \brief Obtain status (runtime) information for PCM handle
* \param pcm PCM handle
* \param status Status container
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_pcm_status(snd_pcm_t *pcm, snd_pcm_status_t *status)
{
* \brief Obtain delay for a running PCM handle
* \param pcm PCM handle
* \param delayp Returned delay in frames
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*
* Delay is distance between current application frame position and
* sound frame position.
/**
* \brief Prepare PCM for use
* \param pcm PCM handle
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_pcm_prepare(snd_pcm_t *pcm)
{
/**
* \brief Reset PCM position
* \param pcm PCM handle
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*
* Reduce PCM delay to 0.
*/
/**
* \brief Start a PCM
* \param pcm PCM handle
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_pcm_start(snd_pcm_t *pcm)
{
/**
* \brief Stop a PCM dropping pending frames
* \param pcm PCM handle
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_pcm_drop(snd_pcm_t *pcm)
{
/**
* \brief Stop a PCM preserving pending frames
* \param pcm PCM handle
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*
* For playback wait for all pending frames to be played and then stop
* the PCM.
* \brief Pause/resume PCM
* \param pcm PCM handle
* \param pause 0 = resume, 1 = pause
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_pcm_pause(snd_pcm_t *pcm, int enable)
{
* \brief Link two PCMs
* \param pcm1 first PCM handle
* \param pcm2 first PCM handle
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*
* The two PCMs will start/stop/prepare in sync.
*/
/**
* \brief Remove a PCM from a linked group
* \param pcm PCM handle
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_pcm_unlink(snd_pcm_t *pcm)
{
* \brief Dump current hardware setup for PCM
* \param pcm PCM handle
* \param out Output handle
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_pcm_dump_hw_setup(snd_pcm_t *pcm, snd_output_t *out)
{
* \brief Dump current software setup for PCM
* \param pcm PCM handle
* \param out Output handle
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_pcm_dump_sw_setup(snd_pcm_t *pcm, snd_output_t *out)
{
* \brief Dump current setup (hardware and software) for PCM
* \param pcm PCM handle
* \param out Output handle
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_pcm_dump_setup(snd_pcm_t *pcm, snd_output_t *out)
{
* \brief Dump status
* \param status Status container
* \param out Output handle
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_pcm_status_dump(snd_pcm_status_t *status, snd_output_t *out)
{
* \brief Dump PCM info
* \param pcm PCM handle
* \param out Output handle
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_pcm_dump(snd_pcm_t *pcm, snd_output_t *out)
{
* \param name ASCII identifier of the PCM handle
* \param stream Wanted stream
* \param mode Open mode (see #SND_PCM_NONBLOCK, #SND_PCM_ASYNC)
- * \return 0 or a negative error code on failure or zero on success
+ * \return 0 on success otherwise a negative error code
*/
int snd_pcm_open(snd_pcm_t **pcmp, const char *name,
snd_pcm_stream_t stream, int mode)
* \brief Wait for a PCM to become ready
* \param pcm PCM handle
* \param timeout maximum time in milliseconds to wait
- * \return 0 or a negative error code on failure or zero on success
+ * \return 0 on success otherwise a negative error code
*/
int snd_pcm_wait(snd_pcm_t *pcm, int timeout)
{
* \param dst_offset offset in frames inside area
* \param samples samples to silence
* \param format PCM sample format
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_pcm_area_silence(const snd_pcm_channel_area_t *dst_area, snd_pcm_uframes_t dst_offset,
unsigned int samples, snd_pcm_format_t format)
* \param channels channels count
* \param frames frames to silence
* \param format PCM sample format
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_pcm_areas_silence(const snd_pcm_channel_area_t *dst_areas, snd_pcm_uframes_t dst_offset,
unsigned int channels, snd_pcm_uframes_t frames, snd_pcm_format_t format)
* \param src_offset offset in frames inside source area
* \param samples samples to copy
* \param format PCM sample format
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_pcm_area_copy(const snd_pcm_channel_area_t *dst_area, snd_pcm_uframes_t dst_offset,
const snd_pcm_channel_area_t *src_area, snd_pcm_uframes_t src_offset,
* \param channels channels count
* \param frames frames to copy
* \param format PCM sample format
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_pcm_areas_copy(const snd_pcm_channel_area_t *dst_areas, snd_pcm_uframes_t dst_offset,
const snd_pcm_channel_area_t *src_areas, snd_pcm_uframes_t src_offset,
* \brief Dump a PCM hardware configuration space
* \param params Configuration space
* \param out Output handle
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_pcm_hw_params_dump(snd_pcm_hw_params_t *params, snd_output_t *out)
{
* \param params Configuration space
* \param rate_num Pointer to returned rate numerator
* \param rate_den Pointer to returned rate denominator
- * \return 0 or a negative error code if the info is not available
+ * \return 0 otherwise a negative error code if the info is not available
*/
int snd_pcm_hw_params_get_rate_numden(const snd_pcm_hw_params_t *params,
unsigned int *rate_num, unsigned int *rate_den)
/**
* \brief Get sample resolution info from a configuration space
* \param params Configuration space
- * \return significative bits in sample or a negative error code if the info is not available
+ * \return significative bits in sample otherwise a negative error code if the info is not available
*/
int snd_pcm_hw_params_get_sbits(const snd_pcm_hw_params_t *params)
{
/**
* \brief Get hardare fifo size info from a configuration space
* \param params Configuration space
- * \return fifo size in frames or a negative error code if the info is not available
+ * \return fifo size in frames otherwise a negative error code if the info is not available
*/
int snd_pcm_hw_params_get_fifo_size(const snd_pcm_hw_params_t *params)
{
/**
* \brief allocate an empty #snd_pcm_access_mask_t using standard malloc
* \param ptr returned pointer
- * \return zero on success otherwise negative error code
+ * \return 0 on success otherwise negative error code
*/
int snd_pcm_access_mask_malloc(snd_pcm_access_mask_t **ptr)
{
/**
* \brief allocate an empty #snd_pcm_format_mask_t using standard malloc
* \param ptr returned pointer
- * \return zero on success otherwise negative error code
+ * \return 0 on success otherwise negative error code
*/
int snd_pcm_format_mask_malloc(snd_pcm_format_mask_t **ptr)
{
/**
* \brief allocate an empty #snd_pcm_subformat_mask_t using standard malloc
* \param ptr returned pointer
- * \return zero on success otherwise negative error code
+ * \return 0 on success otherwise negative error code
*/
int snd_pcm_subformat_mask_malloc(snd_pcm_subformat_mask_t **ptr)
{
/**
* \brief allocate an invalid #snd_pcm_hw_params_t using standard malloc
* \param ptr returned pointer
- * \return zero on success otherwise negative error code
+ * \return 0 on success otherwise negative error code
*/
int snd_pcm_hw_params_malloc(snd_pcm_hw_params_t **ptr)
{
/**
* \brief Extract access type from a configuration space
* \param params Configuration space
- * \return access type or a negative error code if not exactly one is present
+ * \return access type otherwise a negative error code if not exactly one is present
*/
int snd_pcm_hw_params_get_access(const snd_pcm_hw_params_t *params)
{
* \param pcm PCM handle
* \param params Configuration space
* \param val access type
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*/
int snd_pcm_hw_params_set_access(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_access_t val)
{
/**
* \brief Extract format from a configuration space
* \param params Configuration space
- * \return format or a negative error code if not exactly one is present
+ * \return format otherwise a negative error code if not exactly one is present
*/
int snd_pcm_hw_params_get_format(const snd_pcm_hw_params_t *params)
{
* \param pcm PCM handle
* \param params Configuration space
* \param val format
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*/
int snd_pcm_hw_params_set_format(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_format_t val)
{
/**
* \brief Extract subformat from a configuration space
* \param params Configuration space
- * \return subformat or a negative error code if not exactly one is present
+ * \return subformat otherwise a negative error code if not exactly one is present
*/
int snd_pcm_hw_params_get_subformat(const snd_pcm_hw_params_t *params)
{
* \param pcm PCM handle
* \param params Configuration space
* \param val subformat
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*/
int snd_pcm_hw_params_set_subformat(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_subformat_t val)
{
/**
* \brief Extract channels from a configuration space
* \param params Configuration space
- * \return channels count or a negative error code if not exactly one is present
+ * \return channels count otherwise a negative error code if not exactly one is present
*/
int snd_pcm_hw_params_get_channels(const snd_pcm_hw_params_t *params)
{
* \param pcm PCM handle
* \param params Configuration space
* \param val channels count
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*/
int snd_pcm_hw_params_set_channels(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val)
{
* \param pcm PCM handle
* \param params Configuration space
* \param val minimum channels count (on return filled with actual minimum)
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*/
int snd_pcm_hw_params_set_channels_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int *val)
{
* \param pcm PCM handle
* \param params Configuration space
* \param val maximum channels count (on return filled with actual maximum)
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*/
int snd_pcm_hw_params_set_channels_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int *val)
{
* \param params Configuration space
* \param min minimum channels count (on return filled with actual minimum)
* \param max maximum channels count (on return filled with actual maximum)
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*/
int snd_pcm_hw_params_set_channels_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int *min, unsigned int *max)
{
* \brief Extract rate from a configuration space
* \param params Configuration space
* \param dir Sub unit direction
- * \return approximate rate or a negative error code if not exactly one is present
+ * \return approximate rate otherwise a negative error code if not exactly one is present
*
* Actual exact value is <,=,> the approximate one following dir (-1, 0, 1)
*/
* \param params Configuration space
* \param val approximate rate
* \param dir Sub unit direction
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*
* Wanted exact value is <,=,> val following dir (-1,0,1)
*/
* \param params Configuration space
* \param val approximate minimum rate (on return filled with actual minimum)
* \param dir Sub unit direction (on return filled with actual direction)
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*
* Wanted/actual exact minimum is <,=,> val following dir (-1,0,1)
*/
* \param params Configuration space
* \param val approximate maximum rate (on return filled with actual maximum)
* \param dir Sub unit direction (on return filled with actual direction)
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*
* Wanted/actual exact maximum is <,=,> val following dir (-1,0,1)
*/
* \param mindir Sub unit direction for minimum (on return filled with actual direction)
* \param max approximate maximum rate (on return filled with actual maximum)
* \param maxdir Sub unit direction for maximum (on return filled with actual direction)
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*
* Wanted/actual exact min/max is <,=,> val following dir (-1,0,1)
*/
* \brief Extract period time from a configuration space
* \param params Configuration space
* \param dir Sub unit direction
- * \return approximate period duration in us or a negative error code if not exactly one is present
+ * \return approximate period duration in us otherwise a negative error code if not exactly one is present
*
* Actual exact value is <,=,> the approximate one following dir (-1, 0, 1)
*/
* \param params Configuration space
* \param val approximate period duration in us
* \param dir Sub unit direction
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*
* Wanted exact value is <,=,> val following dir (-1,0,1)
*/
* \param params Configuration space
* \param val approximate minimum period duration in us (on return filled with actual minimum)
* \param dir Sub unit direction (on return filled with actual direction)
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*
* Wanted/actual exact minimum is <,=,> val following dir (-1,0,1)
*/
* \param params Configuration space
* \param val approximate maximum period duration in us (on return filled with actual maximum)
* \param dir Sub unit direction (on return filled with actual direction)
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*
* Wanted/actual exact maximum is <,=,> val following dir (-1,0,1)
*/
* \param mindir Sub unit direction for minimum (on return filled with actual direction)
* \param max approximate maximum period duration in us (on return filled with actual maximum)
* \param maxdir Sub unit direction for maximum (on return filled with actual direction)
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*
* Wanted/actual exact min/max is <,=,> val following dir (-1,0,1)
*/
* \brief Extract period size from a configuration space
* \param params Configuration space
* \param dir Sub unit direction
- * \return approximate period size in frames or a negative error code if not exactly one is present
+ * \return approximate period size in frames otherwise a negative error code if not exactly one is present
*
* Actual exact value is <,=,> the approximate one following dir (-1, 0, 1)
*/
* \param params Configuration space
* \param val approximate period size in frames
* \param dir Sub unit direction
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*
* Wanted exact value is <,=,> val following dir (-1,0,1)
*/
* \param params Configuration space
* \param val approximate minimum period size in frames (on return filled with actual minimum)
* \param dir Sub unit direction (on return filled with actual direction)
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*
* Wanted/actual exact minimum is <,=,> val following dir (-1,0,1)
*/
* \param params Configuration space
* \param val approximate maximum period size in frames (on return filled with actual maximum)
* \param dir Sub unit direction (on return filled with actual direction)
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*
* Wanted/actual exact minimum is <,=,> val following dir (-1,0,1)
*/
* \param mindir Sub unit direction for minimum (on return filled with actual direction)
* \param max approximate maximum period size in frames (on return filled with actual maximum)
* \param maxdir Sub unit direction for maximum (on return filled with actual direction)
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*
* Wanted/actual exact min/max is <,=,> val following dir (-1,0,1)
*/
* \brief Restrict a configuration space to contain only integer period sizes
* \param pcm PCM handle
* \param params Configuration space
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*/
int snd_pcm_hw_params_set_period_size_integer(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
{
* \brief Extract periods from a configuration space
* \param params Configuration space
* \param dir Sub unit direction
- * \return approximate periods per buffer or a negative error code if not exactly one is present
+ * \return approximate periods per buffer otherwise a negative error code if not exactly one is present
*
* Actual exact value is <,=,> the approximate one following dir (-1, 0, 1)
*/
* \param params Configuration space
* \param val approximate periods per buffer
* \param dir Sub unit direction
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*
* Wanted exact value is <,=,> val following dir (-1,0,1)
*/
* \param params Configuration space
* \param val approximate minimum periods per buffer (on return filled with actual minimum)
* \param dir Sub unit direction (on return filled with actual direction)
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*
* Wanted/actual exact minimum is <,=,> val following dir (-1,0,1)
*/
* \param params Configuration space
* \param val approximate maximum periods per buffer (on return filled with actual maximum)
* \param dir Sub unit direction (on return filled with actual direction)
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*
* Wanted/actual exact maximum is <,=,> val following dir (-1,0,1)
*/
* \param mindir Sub unit direction for minimum (on return filled with actual direction)
* \param max approximate maximum periods per buffer (on return filled with actual maximum)
* \param maxdir Sub unit direction for maximum (on return filled with actual direction)
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*
* Wanted/actual exact min/max is <,=,> val following dir (-1,0,1)
*/
* \brief Restrict a configuration space to contain only integer periods counts
* \param pcm PCM handle
* \param params Configuration space
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*/
int snd_pcm_hw_params_set_periods_integer(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
{
* \brief Extract buffer time from a configuration space
* \param params Configuration space
* \param dir Sub unit direction
- * \return approximate buffer duration in us or a negative error code if not exactly one is present
+ * \return approximate buffer duration in us otherwise a negative error code if not exactly one is present
*
* Actual exact value is <,=,> the approximate one following dir (-1, 0, 1)
*/
* \param params Configuration space
* \param val approximate buffer duration in us
* \param dir Sub unit direction
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*
* Wanted exact value is <,=,> val following dir (-1,0,1)
*/
* \param params Configuration space
* \param val approximate minimum buffer duration in us (on return filled with actual minimum)
* \param dir Sub unit direction (on return filled with actual direction)
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*
* Wanted/actual exact minimum is <,=,> val following dir (-1,0,1)
*/
* \param params Configuration space
* \param val approximate maximum buffer duration in us (on return filled with actual maximum)
* \param dir Sub unit direction (on return filled with actual direction)
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*
* Wanted/actual exact maximum is <,=,> val following dir (-1,0,1)
*/
* \param mindir Sub unit direction for minimum (on return filled with actual direction)
* \param max approximate maximum buffer duration in us (on return filled with actual maximum)
* \param maxdir Sub unit direction for maximum (on return filled with actual direction)
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*
* Wanted/actual exact min/max is <,=,> val following dir (-1,0,1)
*/
/**
* \brief Extract buffer size from a configuration space
* \param params Configuration space
- * \return buffer size in frames or a negative error code if not exactly one is present
+ * \return buffer size in frames otherwise a negative error code if not exactly one is present
*/
snd_pcm_sframes_t snd_pcm_hw_params_get_buffer_size(const snd_pcm_hw_params_t *params)
{
* \param pcm PCM handle
* \param params Configuration space
* \param val buffer size in frames
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*
* Wanted exact value is <,=,> val following dir (-1,0,1)
*/
* \param params Configuration space
* \param val approximate minimum buffer size in frames (on return filled with actual minimum)
* \param dir Sub unit direction (on return filled with actual direction)
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*
* Wanted/actual exact minimum is <,=,> val following dir (-1,0,1)
*/
* \param params Configuration space
* \param val approximate maximum buffer size in frames (on return filled with actual maximum)
* \param dir Sub unit direction (on return filled with actual direction)
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*
* Wanted/actual exact minimum is <,=,> val following dir (-1,0,1)
*/
* \param mindir Sub unit direction for minimum (on return filled with actual direction)
* \param max approximate maximum buffer size in frames (on return filled with actual maximum)
* \param maxdir Sub unit direction for maximum (on return filled with actual direction)
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*
* Wanted/actual exact min/max is <,=,> val following dir (-1,0,1)
*/
* \brief Extract tick time from a configuration space
* \param params Configuration space
* \param dir Sub unit direction
- * \return approximate tick duration in us or a negative error code if not exactly one is present
+ * \return approximate tick duration in us otherwise a negative error code if not exactly one is present
*
* Actual exact value is <,=,> the approximate one following dir (-1, 0, 1)
*/
* \param params Configuration space
* \param val approximate tick duration in us
* \param dir Sub unit direction
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*
* Wanted exact value is <,=,> val following dir (-1,0,1)
*/
* \param params Configuration space
* \param val approximate minimum tick duration in us (on return filled with actual minimum)
* \param dir Sub unit direction (on return filled with actual direction)
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*
* Wanted/actual exact minimum is <,=,> val following dir (-1,0,1)
*/
* \param params Configuration space
* \param val approximate maximum tick duration in us (on return filled with actual maximum)
* \param dir Sub unit direction (on return filled with actual direction)
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*
* Wanted/actual exact maximum is <,=,> val following dir (-1,0,1)
*/
* \param mindir Sub unit direction for minimum (on return filled with actual direction)
* \param max approximate maximum tick duration in us (on return filled with actual maximum)
* \param maxdir Sub unit direction for maximum (on return filled with actual direction)
- * \return 0 or a negative error code if configuration space would become empty
+ * \return 0 otherwise a negative error code if configuration space would become empty
*
* Wanted/actual exact min/max is <,=,> val following dir (-1,0,1)
*/
* \brief Return current software configuration for a PCM
* \param pcm PCM handle
* \param params Software configuration container
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_pcm_sw_params_current(snd_pcm_t *pcm, snd_pcm_sw_params_t *params)
{
* \brief Dump a software configuration
* \param params Software configuration container
* \param out Output handle
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_pcm_sw_params_dump(snd_pcm_sw_params_t *params, snd_output_t *out)
{
/**
* \brief allocate an invalid #snd_pcm_sw_params_t using standard malloc
* \param ptr returned pointer
- * \return zero on success otherwise negative error code
+ * \return 0 on success otherwise negative error code
*/
int snd_pcm_sw_params_malloc(snd_pcm_sw_params_t **ptr)
{
* \param pcm PCM handle
* \param params Software configuration container
* \param val Start mode
- * \return 0 or a negative error code
+ * \return 0 otherwise a negative error code
*/
int snd_pcm_sw_params_set_start_mode(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_sw_params_t *params, snd_pcm_start_t val)
{
* \param pcm PCM handle
* \param params Software configuration container
* \param val Xrun mode
- * \return 0 or a negative error code
+ * \return 0 otherwise a negative error code
*/
int snd_pcm_sw_params_set_xrun_mode(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_sw_params_t *params, snd_pcm_xrun_t val)
{
* \param pcm PCM handle
* \param params Software configuration container
* \param val Timestamp mode
- * \return 0 or a negative error code
+ * \return 0 otherwise a negative error code
*/
int snd_pcm_sw_params_set_tstamp_mode(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_sw_params_t *params, snd_pcm_tstamp_t val)
{
* \param pcm PCM handle
* \param params Software configuration container
* \param val Minimum ticks to sleep or 0 to disable the use of tick timer
- * \return 0 or a negative error code
+ * \return 0 otherwise a negative error code
*/
int snd_pcm_sw_params_set_sleep_min(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_sw_params_t *params, unsigned int val)
{
* \param pcm PCM handle
* \param params Software configuration container
* \param val Minimum avail frames to consider PCM ready
- * \return 0 or a negative error code
+ * \return 0 otherwise a negative error code
*/
int snd_pcm_sw_params_set_avail_min(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_sw_params_t *params, snd_pcm_uframes_t val)
{
* \param pcm PCM handle
* \param params Software configuration container
* \param val Chunk size (frames are attempted to be transferred in chunks)
- * \return 0 or a negative error code
+ * \return 0 otherwise a negative error code
*/
int snd_pcm_sw_params_set_xfer_align(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_sw_params_t *params, snd_pcm_uframes_t val)
{
* \param pcm PCM handle
* \param params Software configuration container
* \param val Silence threshold in frames
- * \return 0 or a negative error code
+ * \return 0 otherwise a negative error code
*
* A portion of playback buffer is overwritten with silence (see
* #snd_pcm_sw_params_set_silence_size) when playback underrun is nearer
* \param pcm PCM handle
* \param params Software configuration container
* \param val Silence size in frames (0 for disabled)
- * \return 0 or a negative error code
+ * \return 0 otherwise a negative error code
*
* A portion of playback buffer is overwritten with silence when playback
* underrun is nearer than silence threshold (see
/**
* \brief allocate an invalid #snd_pcm_status_t using standard malloc
* \param ptr returned pointer
- * \return zero on success otherwise negative error code
+ * \return 0 on success otherwise negative error code
*/
int snd_pcm_status_malloc(snd_pcm_status_t **ptr)
{
/**
* \brief allocate an invalid #snd_pcm_info_t using standard malloc
* \param ptr returned pointer
- * \return zero on success otherwise negative error code
+ * \return 0 on success otherwise negative error code
*/
int snd_pcm_info_malloc(snd_pcm_info_t **ptr)
{
/**
* \brief Get card from a PCM info container
* \param obj PCM info container
- * \return card number or a negative error code if not associable to a card
+ * \return card number otherwise a negative error code if not associable to a card
*/
int snd_pcm_info_get_card(const snd_pcm_info_t *obj)
{
assert(pcmp);
- if ((ret = snd_ctl_hw_open(&ctl, NULL, card)) < 0)
+ if ((ret = snd_ctl_hw_open(&ctl, NULL, card, 0)) < 0)
return ret;
switch (snd_enum_to_int(stream)) {
* \brief Add a scope to a #SND_PCM_TYPE_METER PCM
* \param pcm PCM handle
* \param scope Scope handle
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_pcm_meter_add_scope(snd_pcm_t *pcm, snd_pcm_scope_t *scope)
{
* \brief Add a s16 pseudo scope to a #SND_PCM_TYPE_METER PCM
* \param name Scope name
* \param scopep Pointer to newly created and added scope
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*
* s16 pseudo scope convert #SND_PCM_TYPE_METER PCM frames in CPU endian
* 16 bit frames for use with other scopes. Don't forget to insert it before
/**
* \brief allocate an invalid #snd_pcm_scope_t using standard malloc
* \param ptr returned pointer
- * \return zero on success otherwise negative error code
+ * \return 0 on success otherwise negative error code
*/
int snd_pcm_scope_malloc(snd_pcm_scope_t **ptr)
{
min rate
min period_size
max periods
- Return 0 on success or a negative number expressing the error.
+ Return 0 on success otherwise a negative error code
*/
int _snd_pcm_hw_params(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
{
* \brief setup the default parameters
* \param rawmidi RawMidi handle
* \param params pointer to a snd_rawmidi_params_t structure
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
static int snd_rawmidi_params_default(snd_rawmidi_t *rawmidi, snd_rawmidi_params_t *params)
{
* \param outputp Returned output handle (NULL if not wanted)
* \param name ASCII identifier of the RawMidi handle
* \param mode Open mode
- * \return a negative error code on failure or zero on success
+ * \return 0 on success otherwise a negative error code
*
* Opens a new connection to the RawMidi interface specified with
* an ASCII identifier and mode.
/**
* \brief close RawMidi handle
* \param rawmidi RawMidi handle
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*
* Closes the specified RawMidi handle and frees all associated
* resources.
* \return ascii identifier of RawMidi handle
*
* Returns the ASCII identifier of given RawMidi handle. It's the same
- * identifier as for snd_rawmidi_open().
+ * identifier specified in snd_rawmidi_open().
*/
const char *snd_rawmidi_name(snd_rawmidi_t *rawmidi)
{
* \brief set nonblock mode
* \param rawmidi RawMidi handle
* \param nonblock 0 = block, 1 = nonblock mode
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_rawmidi_nonblock(snd_rawmidi_t *rawmidi, int nonblock)
{
/**
* \brief allocate a new snd_rawmidi_info_t structure
* \param ptr returned pointer
- * \return zero on success or a negative error code if fails
+ * \return 0 on success otherwise a negative error code if fails
*
* Allocates a new snd_rawmidi_params_t structure using the standard
* malloc C library function.
* \brief get information about RawMidi handle
* \param rawmidi RawMidi handle
* \param info pointer to a snd_rawmidi_info_t structure to be filled
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_rawmidi_info(snd_rawmidi_t *rawmidi, snd_rawmidi_info_t * info)
{
/**
* \brief allocate the snd_rawmidi_params_t structure
* \param ptr returned pointer
- * \return zero on success or a negative error code if fails
+ * \return 0 on success otherwise a negative error code if fails
*
* Allocates a new snd_rawmidi_params_t structure using the standard
* malloc C library function.
* \param rawmidi RawMidi handle
* \param params pointer to a snd_rawmidi_params_t structure
* \param val size in bytes
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_rawmidi_params_set_buffer_size(snd_rawmidi_t *rawmidi ATTRIBUTE_UNUSED, snd_rawmidi_params_t *params, size_t val)
{
* \param rawmidi RawMidi handle
* \param params pointer to snd_rawmidi_params_t structure
* \param val value: 0 = enable to send the active sensing message, 1 = disable
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_rawmidi_params_set_no_active_sensing(snd_rawmidi_t *rawmidi ATTRIBUTE_UNUSED, snd_rawmidi_params_t *params, int val)
{
* \brief get parameters about rawmidi stream
* \param rawmidi RawMidi handle
* \param params pointer to a snd_rawmidi_params_t structure to be filled
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_rawmidi_params(snd_rawmidi_t *rawmidi, snd_rawmidi_params_t * params)
{
* \brief get current parameters about rawmidi stream
* \param rawmidi RawMidi handle
* \param params pointer to a snd_rawmidi_params_t structure to be filled
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_rawmidi_params_current(snd_rawmidi_t *rawmidi, snd_rawmidi_params_t *params)
{
/**
* \brief allocate the snd_rawmidi_status_t structure
* \param ptr returned pointer
- * \return zero on success or a negative error code if fails
+ * \return 0 on success otherwise a negative error code if fails
*
* Allocates a new snd_rawmidi_status_t structure using the standard
* malloc C library function.
* \brief get status of rawmidi stream
* \param rawmidi RawMidi handle
* \param status pointer to a snd_rawmidi_status_t structure to be filled
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_rawmidi_status(snd_rawmidi_t *rawmidi, snd_rawmidi_status_t * status)
{
/**
* \brief drop all bytes in the rawmidi I/O ring buffer immediately
* \param rawmidi RawMidi handle
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*/
int snd_rawmidi_drop(snd_rawmidi_t *rawmidi)
{
/**
* \brief drain all bytes in the rawmidi I/O ring buffer
* \param rawmidi RawMidi handle
- * \return zero on success otherwise a negative error code
+ * \return 0 on success otherwise a negative error code
*
* Waits until all MIDI bytes are not drained (sent) to the
* hardware device.
if (outputp)
*outputp = NULL;
- if ((ret = snd_ctl_hw_open(&ctl, NULL, card)) < 0)
+ if ((ret = snd_ctl_hw_open(&ctl, NULL, card, 0)) < 0)
return ret;
sprintf(filename, SNDRV_FILE_RAWMIDI, card, device);
int fd;
};
-int snd_timer_open(snd_timer_t **handle)
+int snd_timer_open(snd_timer_t **handle, int mode ATTRIBUTE_UNUSED)
{
int fd, ver;
snd_timer_t *tmr;
git://git.alsa-project.org / alsa-lib.git / commitdiff