case SND_PCM_IOCTL_ASYNC:
ctrl->result = snd_pcm_async(pcm, ctrl->u.async.sig, ctrl->u.async.pid);
break;
- case SND_PCM_IOCTL_INFO:
+ case SNDRV_PCM_IOCTL_INFO:
ctrl->result = snd_pcm_info(pcm, (snd_pcm_info_t *) &ctrl->u.info);
break;
- case SND_PCM_IOCTL_HW_REFINE:
+ case SNDRV_PCM_IOCTL_HW_REFINE:
ctrl->result = snd_pcm_hw_refine(pcm, (snd_pcm_hw_params_t *) &ctrl->u.hw_refine);
break;
- case SND_PCM_IOCTL_HW_PARAMS:
+ case SNDRV_PCM_IOCTL_HW_PARAMS:
ctrl->result = snd_pcm_hw_params(pcm, (snd_pcm_hw_params_t *) &ctrl->u.hw_params);
break;
- case SND_PCM_IOCTL_HW_FREE:
+ case SNDRV_PCM_IOCTL_HW_FREE:
ctrl->result = snd_pcm_hw_free(pcm);
break;
- case SND_PCM_IOCTL_SW_PARAMS:
+ case SNDRV_PCM_IOCTL_SW_PARAMS:
ctrl->result = snd_pcm_sw_params(pcm, (snd_pcm_sw_params_t *) &ctrl->u.sw_params);
break;
- case SND_PCM_IOCTL_STATUS:
+ case SNDRV_PCM_IOCTL_STATUS:
ctrl->result = snd_pcm_status(pcm, (snd_pcm_status_t *) &ctrl->u.status);
break;
case SND_PCM_IOCTL_STATE:
ctrl->result = snd_pcm_state(pcm);
break;
- case SND_PCM_IOCTL_DELAY:
+ case SNDRV_PCM_IOCTL_DELAY:
ctrl->result = snd_pcm_delay(pcm, (snd_pcm_sframes_t *) &ctrl->u.delay.frames);
break;
case SND_PCM_IOCTL_AVAIL_UPDATE:
ctrl->result = snd_pcm_avail_update(pcm);
ctrl->hw_ptr = *pcm->hw_ptr;
break;
- case SND_PCM_IOCTL_PREPARE:
+ case SNDRV_PCM_IOCTL_PREPARE:
ctrl->result = snd_pcm_prepare(pcm);
ctrl->appl_ptr = *pcm->appl_ptr;
ctrl->hw_ptr = *pcm->hw_ptr;
break;
- case SND_PCM_IOCTL_RESET:
+ case SNDRV_PCM_IOCTL_RESET:
ctrl->result = snd_pcm_reset(pcm);
ctrl->appl_ptr = *pcm->appl_ptr;
ctrl->hw_ptr = *pcm->hw_ptr;
break;
- case SND_PCM_IOCTL_START:
+ case SNDRV_PCM_IOCTL_START:
ctrl->result = snd_pcm_start(pcm);
ctrl->appl_ptr = *pcm->appl_ptr;
ctrl->hw_ptr = *pcm->hw_ptr;
break;
- case SND_PCM_IOCTL_DRAIN:
+ case SNDRV_PCM_IOCTL_DRAIN:
ctrl->result = snd_pcm_drain(pcm);
break;
- case SND_PCM_IOCTL_DROP:
+ case SNDRV_PCM_IOCTL_DROP:
ctrl->result = snd_pcm_drop(pcm);
break;
- case SND_PCM_IOCTL_PAUSE:
+ case SNDRV_PCM_IOCTL_PAUSE:
ctrl->result = snd_pcm_pause(pcm, ctrl->u.pause.enable);
break;
- case SND_PCM_IOCTL_CHANNEL_INFO:
+ case SNDRV_PCM_IOCTL_CHANNEL_INFO:
ctrl->result = snd_pcm_channel_info(pcm, (snd_pcm_channel_info_t *) &ctrl->u.channel_info);
if (ctrl->result >= 0 &&
ctrl->u.channel_info.type == SND_PCM_AREA_MMAP)
return shm_ack_fd(client, ctrl->u.channel_info.u.mmap.fd);
break;
- case SND_PCM_IOCTL_REWIND:
+ case SNDRV_PCM_IOCTL_REWIND:
ctrl->result = snd_pcm_rewind(pcm, ctrl->u.rewind.frames);
ctrl->appl_ptr = *pcm->appl_ptr;
break;
- case SND_PCM_IOCTL_LINK:
+ case SNDRV_PCM_IOCTL_LINK:
{
/* FIXME */
ctrl->result = -ENOSYS;
break;
}
- case SND_PCM_IOCTL_UNLINK:
+ case SNDRV_PCM_IOCTL_UNLINK:
ctrl->result = snd_pcm_unlink(pcm);
break;
case SND_PCM_IOCTL_MMAP:
ctrl->cmd = 0;
ctl = client->device.control.handle;
switch (cmd) {
- case SND_CTL_IOCTL_HW_INFO:
+ case SNDRV_CTL_IOCTL_HW_INFO:
ctrl->result = snd_ctl_hw_info(ctl, &ctrl->u.hw_info);
break;
- case SND_CTL_IOCTL_CONTROL_LIST:
+ case SNDRV_CTL_IOCTL_CONTROL_LIST:
{
size_t maxsize = CTL_SHM_DATA_MAXLEN;
if (ctrl->u.clist.controls_request * sizeof(*ctrl->u.clist.pids) > maxsize) {
ctrl->result = snd_ctl_clist(ctl, &ctrl->u.clist);
break;
}
- case SND_CTL_IOCTL_CONTROL_INFO:
+ case SNDRV_CTL_IOCTL_CONTROL_INFO:
ctrl->result = snd_ctl_cinfo(ctl, &ctrl->u.cinfo);
break;
- case SND_CTL_IOCTL_CONTROL_READ:
+ case SNDRV_CTL_IOCTL_CONTROL_READ:
ctrl->result = snd_ctl_cread(ctl, &ctrl->u.cread);
break;
- case SND_CTL_IOCTL_CONTROL_WRITE:
+ case SNDRV_CTL_IOCTL_CONTROL_WRITE:
ctrl->result = snd_ctl_cwrite(ctl, &ctrl->u.cwrite);
break;
- case SND_CTL_IOCTL_HWDEP_NEXT_DEVICE:
+ case SNDRV_CTL_IOCTL_HWDEP_NEXT_DEVICE:
ctrl->result = snd_ctl_hwdep_next_device(ctl, &ctrl->u.device);
break;
- case SND_CTL_IOCTL_HWDEP_INFO:
+ case SNDRV_CTL_IOCTL_HWDEP_INFO:
ctrl->result = snd_ctl_hwdep_info(ctl, &ctrl->u.hwdep_info);
break;
- case SND_CTL_IOCTL_PCM_NEXT_DEVICE:
+ case SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE:
ctrl->result = snd_ctl_pcm_next_device(ctl, &ctrl->u.device);
break;
- case SND_CTL_IOCTL_PCM_INFO:
+ case SNDRV_CTL_IOCTL_PCM_INFO:
ctrl->result = snd_ctl_pcm_info(ctl, &ctrl->u.pcm_info);
break;
- case SND_CTL_IOCTL_PCM_PREFER_SUBDEVICE:
+ case SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE:
ctrl->result = snd_ctl_pcm_prefer_subdevice(ctl, ctrl->u.pcm_prefer_subdevice);
break;
- case SND_CTL_IOCTL_RAWMIDI_NEXT_DEVICE:
+ case SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE:
ctrl->result = snd_ctl_rawmidi_next_device(ctl, &ctrl->u.device);
break;
- case SND_CTL_IOCTL_RAWMIDI_INFO:
+ case SNDRV_CTL_IOCTL_RAWMIDI_INFO:
ctrl->result = snd_ctl_rawmidi_info(ctl, &ctrl->u.rawmidi_info);
break;
- case SND_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE:
+ case SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE:
ctrl->result = snd_ctl_rawmidi_prefer_subdevice(ctl, ctrl->u.rawmidi_prefer_subdevice);
break;
case SND_CTL_IOCTL_READ:
#define __ASOUNDLIB_H
#include <linux/asound.h>
+#include <linux/asoundef.h>
#include <linux/asequencer.h>
#include <unistd.h>
#include <stdio.h>
#define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
#endif
+
+/* Temporary hack */
+/* asound.h */
+typedef struct timeval snd_timestamp_t;
+typedef struct interval interval_t;
+typedef enum sndrv_card_type snd_card_type;
+typedef sndrv_pcm_uframes_t snd_pcm_uframes_t;
+typedef sndrv_pcm_sframes_t snd_pcm_sframes_t;
+typedef struct sndrv_aes_iec958 snd_aes_iec958_t;
+typedef union sndrv_digital_audio snd_digital_audio_t;
+typedef enum sndrv_hwdep_type snd_hwdep_type_t;
+typedef struct sndrv_hwdep_info snd_hwdep_info_t;
+typedef enum sndrv_pcm_class snd_pcm_class_t;
+typedef enum sndrv_pcm_subclass snd_pcm_subclass_t;
+typedef enum sndrv_pcm_stream snd_pcm_stream_t;
+typedef enum sndrv_pcm_access snd_pcm_access_t;
+typedef enum sndrv_pcm_format snd_pcm_format_t;
+typedef enum sndrv_pcm_subformat snd_pcm_subformat_t;
+typedef enum sndrv_pcm_state snd_pcm_state_t;
+typedef union sndrv_pcm_sync_id snd_pcm_sync_id_t;
+typedef struct sndrv_pcm_info snd_pcm_info_t;
+typedef enum sndrv_pcm_hw_param snd_pcm_hw_param_t;
+typedef struct sndrv_pcm_hw_params snd_pcm_hw_params_t;
+typedef enum sndrv_pcm_start snd_pcm_start_t;
+typedef enum sndrv_pcm_xrun snd_pcm_xrun_t;
+typedef enum sndrv_pcm_tstamp snd_pcm_tstamp_t;
+typedef struct sndrv_pcm_sw_params snd_pcm_sw_params_t;
+typedef struct sndrv_pcm_hw_channel_info snd_pcm_hw_channel_info_t;
+typedef struct sndrv_pcm_status snd_pcm_status_t;
+typedef struct sndrv_pcm_mmap_status snd_pcm_mmap_status_t;
+typedef struct sndrv_pcm_mmap_control snd_pcm_mmap_control_t;
+typedef struct sndrv_xferi snd_xferi_t;
+typedef struct sndrv_xfern snd_xfern_t;
+typedef enum sndrv_mcmd snd_mcmd_t;
+typedef enum sndrv_mctl snd_mctl_t;
+typedef enum sndrv_rawmidi_stream snd_rawmidi_stream_t;
+typedef struct sndrv_rawmidi_info snd_rawmidi_info_t;
+typedef struct sndrv_rawmidi_params snd_rawmidi_params_t;
+typedef struct sndrv_rawmidi_status snd_rawmidi_status_t;
+typedef enum sndrv_timer_type snd_timer_type_t;
+typedef enum sndrv_timer_slave_type snd_timer_slave_type_t;
+typedef enum sndrv_timer_global snd_timer_global_t;
+typedef struct sndrv_timer_id snd_timer_id_t;
+typedef struct sndrv_timer_select snd_timer_select_t;
+typedef struct sndrv_timer_info snd_timer_info_t;
+typedef struct sndrv_timer_params snd_timer_params_t;
+typedef struct sndrv_timer_status snd_timer_status_t;
+typedef struct sndrv_timer_read snd_timer_read_t;
+typedef struct sndrv_ctl_hw_info snd_ctl_hw_info_t;
+typedef enum sndrv_control_type snd_control_type_t;
+typedef enum sndrv_control_iface snd_control_iface_t;
+typedef struct sndrv_control_id snd_control_id_t;
+typedef struct sndrv_control_list snd_control_list_t;
+typedef struct sndrv_control_info snd_control_info_t;
+typedef struct sndrv_control snd_control_t;
+typedef enum sndrv_ctl_event_type snd_ctl_event_type_t;
+typedef struct sndrv_ctl_event snd_ctl_event_t;
+typedef struct sndrv_xferv snd_xferv_t;
+
+#ifdef SNDRV_LITTLE_ENDIAN
+#define SND_LITTLE_ENDIAN SNDRV_LITTLE_ENDIAN
+#endif
+
+#ifdef SNDRV_BIG_ENDIAN
+#define SND_BIG_ENDIAN SNDRV_BIG_ENDIAN
+#endif
+
+#define SND_CARD_TYPE_GUS_CLASSIC SNDRV_CARD_TYPE_GUS_CLASSIC
+#define SND_CARD_TYPE_GUS_EXTREME SNDRV_CARD_TYPE_GUS_EXTREME
+#define SND_CARD_TYPE_GUS_ACE SNDRV_CARD_TYPE_GUS_ACE
+#define SND_CARD_TYPE_GUS_MAX SNDRV_CARD_TYPE_GUS_MAX
+#define SND_CARD_TYPE_AMD_INTERWAVE SNDRV_CARD_TYPE_AMD_INTERWAVE
+#define SND_CARD_TYPE_SB_10 SNDRV_CARD_TYPE_SB_10
+#define SND_CARD_TYPE_SB_20 SNDRV_CARD_TYPE_SB_20
+#define SND_CARD_TYPE_SB_PRO SNDRV_CARD_TYPE_SB_PRO
+#define SND_CARD_TYPE_SB_16 SNDRV_CARD_TYPE_SB_16
+#define SND_CARD_TYPE_SB_AWE SNDRV_CARD_TYPE_SB_AWE
+#define SND_CARD_TYPE_ESS_ES1688 SNDRV_CARD_TYPE_ESS_ES1688
+#define SND_CARD_TYPE_OPL3_SA2 SNDRV_CARD_TYPE_OPL3_SA2
+#define SND_CARD_TYPE_MOZART SNDRV_CARD_TYPE_MOZART
+#define SND_CARD_TYPE_S3_SONICVIBES SNDRV_CARD_TYPE_S3_SONICVIBES
+#define SND_CARD_TYPE_ENS1370 SNDRV_CARD_TYPE_ENS1370
+#define SND_CARD_TYPE_ENS1371 SNDRV_CARD_TYPE_ENS1371
+#define SND_CARD_TYPE_CS4232 SNDRV_CARD_TYPE_CS4232
+#define SND_CARD_TYPE_CS4236 SNDRV_CARD_TYPE_CS4236
+#define SND_CARD_TYPE_AMD_INTERWAVE_STB SNDRV_CARD_TYPE_AMD_INTERWAVE_STB
+#define SND_CARD_TYPE_ESS_ES1938 SNDRV_CARD_TYPE_ESS_ES1938
+#define SND_CARD_TYPE_ESS_ES18XX SNDRV_CARD_TYPE_ESS_ES18XX
+#define SND_CARD_TYPE_CS4231 SNDRV_CARD_TYPE_CS4231
+#define SND_CARD_TYPE_OPTI92X SNDRV_CARD_TYPE_OPTI92X
+#define SND_CARD_TYPE_SERIAL SNDRV_CARD_TYPE_SERIAL
+#define SND_CARD_TYPE_AD1848 SNDRV_CARD_TYPE_AD1848
+#define SND_CARD_TYPE_TRID4DWAVEDX SNDRV_CARD_TYPE_TRID4DWAVEDX
+#define SND_CARD_TYPE_TRID4DWAVENX SNDRV_CARD_TYPE_TRID4DWAVENX
+#define SND_CARD_TYPE_SGALAXY SNDRV_CARD_TYPE_SGALAXY
+#define SND_CARD_TYPE_CS46XX SNDRV_CARD_TYPE_CS46XX
+#define SND_CARD_TYPE_WAVEFRONT SNDRV_CARD_TYPE_WAVEFRONT
+#define SND_CARD_TYPE_TROPEZ SNDRV_CARD_TYPE_TROPEZ
+#define SND_CARD_TYPE_TROPEZPLUS SNDRV_CARD_TYPE_TROPEZPLUS
+#define SND_CARD_TYPE_MAUI SNDRV_CARD_TYPE_MAUI
+#define SND_CARD_TYPE_CMI8330 SNDRV_CARD_TYPE_CMI8330
+#define SND_CARD_TYPE_DUMMY SNDRV_CARD_TYPE_DUMMY
+#define SND_CARD_TYPE_ALS100 SNDRV_CARD_TYPE_ALS100
+#define SND_CARD_TYPE_SHARE SNDRV_CARD_TYPE_SHARE
+#define SND_CARD_TYPE_SI_7018 SNDRV_CARD_TYPE_SI_7018
+#define SND_CARD_TYPE_OPTI93X SNDRV_CARD_TYPE_OPTI93X
+#define SND_CARD_TYPE_MTPAV SNDRV_CARD_TYPE_MTPAV
+#define SND_CARD_TYPE_VIRMIDI SNDRV_CARD_TYPE_VIRMIDI
+#define SND_CARD_TYPE_EMU10K1 SNDRV_CARD_TYPE_EMU10K1
+#define SND_CARD_TYPE_HAMMERFALL SNDRV_CARD_TYPE_HAMMERFALL
+#define SND_CARD_TYPE_HAMMERFALL_LIGHT SNDRV_CARD_TYPE_HAMMERFALL_LIGHT
+#define SND_CARD_TYPE_ICE1712 SNDRV_CARD_TYPE_ICE1712
+#define SND_CARD_TYPE_CMI8338 SNDRV_CARD_TYPE_CMI8338
+#define SND_CARD_TYPE_CMI8738 SNDRV_CARD_TYPE_CMI8738
+#define SND_CARD_TYPE_AD1816A SNDRV_CARD_TYPE_AD1816A
+#define SND_CARD_TYPE_INTEL8X0 SNDRV_CARD_TYPE_INTEL8X0
+#define SND_CARD_TYPE_ESS_ESOLDM1 SNDRV_CARD_TYPE_ESS_ESOLDM1
+#define SND_CARD_TYPE_ESS_ES1968 SNDRV_CARD_TYPE_ESS_ES1968
+#define SND_CARD_TYPE_ESS_ES1978 SNDRV_CARD_TYPE_ESS_ES1978
+#define SND_CARD_TYPE_DIGI96 SNDRV_CARD_TYPE_DIGI96
+#define SND_CARD_TYPE_VIA82C686A SNDRV_CARD_TYPE_VIA82C686A
+#define SND_CARD_TYPE_FM801 SNDRV_CARD_TYPE_FM801
+#define SND_CARD_TYPE_AZT2320 SNDRV_CARD_TYPE_AZT2320
+#define SND_CARD_TYPE_PRODIF_PLUS SNDRV_CARD_TYPE_PRODIF_PLUS
+#define SND_CARD_TYPE_YMFPCI SNDRV_CARD_TYPE_YMFPCI
+#define SND_CARD_TYPE_CS4281 SNDRV_CARD_TYPE_CS4281
+#define SND_CARD_TYPE_MPU401_UART SNDRV_CARD_TYPE_MPU401_UART
+#define SND_CARD_TYPE_ALS4000 SNDRV_CARD_TYPE_ALS4000
+#define SND_CARD_TYPE_ALLEGRO_1 SNDRV_CARD_TYPE_ALLEGRO_1
+#define SND_CARD_TYPE_ALLEGRO SNDRV_CARD_TYPE_ALLEGRO
+#define SND_CARD_TYPE_MAESTRO3 SNDRV_CARD_TYPE_MAESTRO3
+#define SND_CARD_TYPE_AWACS SNDRV_CARD_TYPE_AWACS
+#define SND_CARD_TYPE_NM256AV SNDRV_CARD_TYPE_NM256AV
+#define SND_CARD_TYPE_NM256ZX SNDRV_CARD_TYPE_NM256ZX
+#define SND_CARD_TYPE_VIA8233 SNDRV_CARD_TYPE_VIA8233
+#define SND_CARD_TYPE_LAST SNDRV_CARD_TYPE_LAST
+#define SND_HWDEP_TYPE_OPL2 SNDRV_HWDEP_TYPE_OPL2
+#define SND_HWDEP_TYPE_OPL3 SNDRV_HWDEP_TYPE_OPL3
+#define SND_HWDEP_TYPE_OPL4 SNDRV_HWDEP_TYPE_OPL4
+#define SND_HWDEP_TYPE_SB16CSP SNDRV_HWDEP_TYPE_SB16CSP
+#define SND_HWDEP_TYPE_EMU10K1 SNDRV_HWDEP_TYPE_EMU10K1
+#define SND_HWDEP_TYPE_YSS225 SNDRV_HWDEP_TYPE_YSS225
+#define SND_HWDEP_TYPE_ICS2115 SNDRV_HWDEP_TYPE_ICS2115
+#define SND_HWDEP_TYPE_LAST SNDRV_HWDEP_TYPE_LAST
+#define SND_PCM_CLASS_GENERIC SNDRV_PCM_CLASS_GENERIC
+#define SND_PCM_CLASS_MULTI SNDRV_PCM_CLASS_MULTI
+#define SND_PCM_CLASS_MODEM SNDRV_PCM_CLASS_MODEM
+#define SND_PCM_CLASS_DIGITIZER SNDRV_PCM_CLASS_DIGITIZER
+#define SND_PCM_SUBCLASS_GENERIC_MIX SNDRV_PCM_SUBCLASS_GENERIC_MIX
+#define SND_PCM_SUBCLASS_MULTI_MIX SNDRV_PCM_SUBCLASS_MULTI_MIX
+#define SND_PCM_STREAM_PLAYBACK SNDRV_PCM_STREAM_PLAYBACK
+#define SND_PCM_STREAM_CAPTURE SNDRV_PCM_STREAM_CAPTURE
+#define SND_PCM_STREAM_LAST SNDRV_PCM_STREAM_LAST
+#define SND_PCM_ACCESS_MMAP_INTERLEAVED SNDRV_PCM_ACCESS_MMAP_INTERLEAVED
+#define SND_PCM_ACCESS_MMAP_NONINTERLEAVED SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED
+#define SND_PCM_ACCESS_MMAP_COMPLEX SNDRV_PCM_ACCESS_MMAP_COMPLEX
+#define SND_PCM_ACCESS_RW_INTERLEAVED SNDRV_PCM_ACCESS_RW_INTERLEAVED
+#define SND_PCM_ACCESS_RW_NONINTERLEAVED SNDRV_PCM_ACCESS_RW_NONINTERLEAVED
+#define SND_PCM_ACCESS_LAST SNDRV_PCM_ACCESS_LAST
+#define SND_PCM_FORMAT_S8 SNDRV_PCM_FORMAT_S8
+#define SND_PCM_FORMAT_U8 SNDRV_PCM_FORMAT_U8
+#define SND_PCM_FORMAT_S16_LE SNDRV_PCM_FORMAT_S16_LE
+#define SND_PCM_FORMAT_S16_BE SNDRV_PCM_FORMAT_S16_BE
+#define SND_PCM_FORMAT_U16_LE SNDRV_PCM_FORMAT_U16_LE
+#define SND_PCM_FORMAT_U16_BE SNDRV_PCM_FORMAT_U16_BE
+#define SND_PCM_FORMAT_S24_LE SNDRV_PCM_FORMAT_S24_LE
+#define SND_PCM_FORMAT_S24_BE SNDRV_PCM_FORMAT_S24_BE
+#define SND_PCM_FORMAT_U24_LE SNDRV_PCM_FORMAT_U24_LE
+#define SND_PCM_FORMAT_U24_BE SNDRV_PCM_FORMAT_U24_BE
+#define SND_PCM_FORMAT_S32_LE SNDRV_PCM_FORMAT_S32_LE
+#define SND_PCM_FORMAT_S32_BE SNDRV_PCM_FORMAT_S32_BE
+#define SND_PCM_FORMAT_U32_LE SNDRV_PCM_FORMAT_U32_LE
+#define SND_PCM_FORMAT_U32_BE SNDRV_PCM_FORMAT_U32_BE
+#define SND_PCM_FORMAT_FLOAT_LE SNDRV_PCM_FORMAT_FLOAT_LE
+#define SND_PCM_FORMAT_FLOAT_BE SNDRV_PCM_FORMAT_FLOAT_BE
+#define SND_PCM_FORMAT_FLOAT64_LE SNDRV_PCM_FORMAT_FLOAT64_LE
+#define SND_PCM_FORMAT_FLOAT64_BE SNDRV_PCM_FORMAT_FLOAT64_BE
+#define SND_PCM_FORMAT_IEC958_SUBFRAME_LE SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE
+#define SND_PCM_FORMAT_IEC958_SUBFRAME_BE SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE
+#define SND_PCM_FORMAT_MU_LAW SNDRV_PCM_FORMAT_MU_LAW
+#define SND_PCM_FORMAT_A_LAW SNDRV_PCM_FORMAT_A_LAW
+#define SND_PCM_FORMAT_IMA_ADPCM SNDRV_PCM_FORMAT_IMA_ADPCM
+#define SND_PCM_FORMAT_MPEG SNDRV_PCM_FORMAT_MPEG
+#define SND_PCM_FORMAT_GSM SNDRV_PCM_FORMAT_GSM
+#define SND_PCM_FORMAT_SPECIAL SNDRV_PCM_FORMAT_SPECIAL
+#define SND_PCM_FORMAT_LAST SNDRV_PCM_FORMAT_LAST
+#define SND_PCM_FORMAT_S16 SNDRV_PCM_FORMAT_S16
+#define SND_PCM_FORMAT_U16 SNDRV_PCM_FORMAT_U16
+#define SND_PCM_FORMAT_S24 SNDRV_PCM_FORMAT_S24
+#define SND_PCM_FORMAT_U24 SNDRV_PCM_FORMAT_U24
+#define SND_PCM_FORMAT_S32 SNDRV_PCM_FORMAT_S32
+#define SND_PCM_FORMAT_U32 SNDRV_PCM_FORMAT_U32
+#define SND_PCM_FORMAT_FLOAT SNDRV_PCM_FORMAT_FLOAT
+#define SND_PCM_FORMAT_FLOAT64 SNDRV_PCM_FORMAT_FLOAT64
+#define SND_PCM_FORMAT_IEC958_SUBFRAME SNDRV_PCM_FORMAT_IEC958_SUBFRAME
+#define SND_PCM_FORMAT_S16 SNDRV_PCM_FORMAT_S16
+#define SND_PCM_FORMAT_U16 SNDRV_PCM_FORMAT_U16
+#define SND_PCM_FORMAT_S24 SNDRV_PCM_FORMAT_S24
+#define SND_PCM_FORMAT_U24 SNDRV_PCM_FORMAT_U24
+#define SND_PCM_FORMAT_S32 SNDRV_PCM_FORMAT_S32
+#define SND_PCM_FORMAT_U32 SNDRV_PCM_FORMAT_U32
+#define SND_PCM_FORMAT_FLOAT SNDRV_PCM_FORMAT_FLOAT
+#define SND_PCM_FORMAT_FLOAT64 SNDRV_PCM_FORMAT_FLOAT64
+#define SND_PCM_FORMAT_IEC958_SUBFRAME SNDRV_PCM_FORMAT_IEC958_SUBFRAME
+#define SND_PCM_SUBFORMAT_STD SNDRV_PCM_SUBFORMAT_STD
+#define SND_PCM_SUBFORMAT_LAST SNDRV_PCM_SUBFORMAT_LAST
+#define SND_PCM_INFO_MMAP SNDRV_PCM_INFO_MMAP
+#define SND_PCM_INFO_MMAP_VALID SNDRV_PCM_INFO_MMAP_VALID
+#define SND_PCM_INFO_DOUBLE SNDRV_PCM_INFO_DOUBLE
+#define SND_PCM_INFO_BATCH SNDRV_PCM_INFO_BATCH
+#define SND_PCM_INFO_INTERLEAVED SNDRV_PCM_INFO_INTERLEAVED
+#define SND_PCM_INFO_NONINTERLEAVED SNDRV_PCM_INFO_NONINTERLEAVED
+#define SND_PCM_INFO_COMPLEX SNDRV_PCM_INFO_COMPLEX
+#define SND_PCM_INFO_BLOCK_TRANSFER SNDRV_PCM_INFO_BLOCK_TRANSFER
+#define SND_PCM_INFO_OVERRANGE SNDRV_PCM_INFO_OVERRANGE
+#define SND_PCM_INFO_PAUSE SNDRV_PCM_INFO_PAUSE
+#define SND_PCM_INFO_HALF_DUPLEX SNDRV_PCM_INFO_HALF_DUPLEX
+#define SND_PCM_INFO_JOINT_DUPLEX SNDRV_PCM_INFO_JOINT_DUPLEX
+#define SND_PCM_INFO_SYNC_START SNDRV_PCM_INFO_SYNC_START
+#define SND_PCM_STATE_OPEN SNDRV_PCM_STATE_OPEN
+#define SND_PCM_STATE_SETUP SNDRV_PCM_STATE_SETUP
+#define SND_PCM_STATE_PREPARED SNDRV_PCM_STATE_PREPARED
+#define SND_PCM_STATE_RUNNING SNDRV_PCM_STATE_RUNNING
+#define SND_PCM_STATE_XRUN SNDRV_PCM_STATE_XRUN
+#define SND_PCM_STATE_DRAINING SNDRV_PCM_STATE_DRAINING
+#define SND_PCM_STATE_PAUSED SNDRV_PCM_STATE_PAUSED
+#define SND_PCM_STATE_LAST SNDRV_PCM_STATE_LAST
+#define SND_PCM_MMAP_OFFSET_DATA SNDRV_PCM_MMAP_OFFSET_DATA
+#define SND_PCM_MMAP_OFFSET_STATUS SNDRV_PCM_MMAP_OFFSET_STATUS
+#define SND_PCM_MMAP_OFFSET_CONTROL SNDRV_PCM_MMAP_OFFSET_CONTROL
+#define SND_PCM_HW_PARAM_ACCESS SNDRV_PCM_HW_PARAM_ACCESS
+#define SND_PCM_HW_PARAM_FIRST_MASK SNDRV_PCM_HW_PARAM_FIRST_MASK
+#define SND_PCM_HW_PARAM_FORMAT SNDRV_PCM_HW_PARAM_FORMAT
+#define SND_PCM_HW_PARAM_SUBFORMAT SNDRV_PCM_HW_PARAM_SUBFORMAT
+#define SND_PCM_HW_PARAM_LAST_MASK SNDRV_PCM_HW_PARAM_LAST_MASK
+#define SND_PCM_HW_PARAM_SAMPLE_BITS SNDRV_PCM_HW_PARAM_SAMPLE_BITS
+#define SND_PCM_HW_PARAM_FIRST_INTERVAL SNDRV_PCM_HW_PARAM_FIRST_INTERVAL
+#define SND_PCM_HW_PARAM_FRAME_BITS SNDRV_PCM_HW_PARAM_FRAME_BITS
+#define SND_PCM_HW_PARAM_CHANNELS SNDRV_PCM_HW_PARAM_CHANNELS
+#define SND_PCM_HW_PARAM_RATE SNDRV_PCM_HW_PARAM_RATE
+#define SND_PCM_HW_PARAM_PERIOD_TIME SNDRV_PCM_HW_PARAM_PERIOD_TIME
+#define SND_PCM_HW_PARAM_PERIOD_SIZE SNDRV_PCM_HW_PARAM_PERIOD_SIZE
+#define SND_PCM_HW_PARAM_PERIOD_BYTES SNDRV_PCM_HW_PARAM_PERIOD_BYTES
+#define SND_PCM_HW_PARAM_PERIODS SNDRV_PCM_HW_PARAM_PERIODS
+#define SND_PCM_HW_PARAM_BUFFER_TIME SNDRV_PCM_HW_PARAM_BUFFER_TIME
+#define SND_PCM_HW_PARAM_BUFFER_SIZE SNDRV_PCM_HW_PARAM_BUFFER_SIZE
+#define SND_PCM_HW_PARAM_BUFFER_BYTES SNDRV_PCM_HW_PARAM_BUFFER_BYTES
+#define SND_PCM_HW_PARAM_TICK_TIME SNDRV_PCM_HW_PARAM_TICK_TIME
+#define SND_PCM_HW_PARAM_LAST_INTERVAL SNDRV_PCM_HW_PARAM_LAST_INTERVAL
+#define SND_PCM_HW_PARAM_LAST SNDRV_PCM_HW_PARAM_LAST
+#define SND_PCM_HW_PARAMS_RUNTIME SNDRV_PCM_HW_PARAMS_RUNTIME
+#define SND_PCM_HW_PARAM_LAST_MASK SNDRV_PCM_HW_PARAM_LAST_MASK
+#define SND_PCM_HW_PARAM_FIRST_MASK SNDRV_PCM_HW_PARAM_FIRST_MASK
+#define SND_PCM_HW_PARAM_LAST_INTERVAL SNDRV_PCM_HW_PARAM_LAST_INTERVAL
+#define SND_PCM_HW_PARAM_FIRST_INTERVAL SNDRV_PCM_HW_PARAM_FIRST_INTERVAL
+#define SND_PCM_START_DATA SNDRV_PCM_START_DATA
+#define SND_PCM_START_EXPLICIT SNDRV_PCM_START_EXPLICIT
+#define SND_PCM_START_LAST SNDRV_PCM_START_LAST
+#define SND_PCM_XRUN_NONE SNDRV_PCM_XRUN_NONE
+#define SND_PCM_XRUN_STOP SNDRV_PCM_XRUN_STOP
+#define SND_PCM_XRUN_LAST SNDRV_PCM_XRUN_LAST
+#define SND_PCM_TSTAMP_NONE SNDRV_PCM_TSTAMP_NONE
+#define SND_PCM_TSTAMP_MMAP SNDRV_PCM_TSTAMP_MMAP
+#define SND_PCM_TSTAMP_LAST SNDRV_PCM_TSTAMP_LAST
+#define SND_PCM_STATE_XXXX SNDRV_PCM_STATE_XXXX
+#define SND_MIDI_CHANNELS SNDRV_MIDI_CHANNELS
+#define SND_MIDI_GM_DRUM_CHANNEL SNDRV_MIDI_GM_DRUM_CHANNEL
+#define SND_RAWMIDI_STREAM_OUTPUT SNDRV_RAWMIDI_STREAM_OUTPUT
+#define SND_RAWMIDI_STREAM_INPUT SNDRV_RAWMIDI_STREAM_INPUT
+#define SND_RAWMIDI_INFO_OUTPUT SNDRV_RAWMIDI_INFO_OUTPUT
+#define SND_RAWMIDI_INFO_INPUT SNDRV_RAWMIDI_INFO_INPUT
+#define SND_RAWMIDI_INFO_DUPLEX SNDRV_RAWMIDI_INFO_DUPLEX
+#define SND_RAWMIDI_INFO_XXXX SNDRV_RAWMIDI_INFO_XXXX
+#define SND_RAWMIDI_PARBIT_STREAM SNDRV_RAWMIDI_PARBIT_STREAM
+#define SND_RAWMIDI_PARBIT_BUFFER_SIZE SNDRV_RAWMIDI_PARBIT_BUFFER_SIZE
+#define SND_RAWMIDI_PARBIT_AVAIL_MIN SNDRV_RAWMIDI_PARBIT_AVAIL_MIN
+#define SND_TIMER_TYPE_NONE SNDRV_TIMER_TYPE_NONE
+#define SND_TIMER_TYPE_SLAVE SNDRV_TIMER_TYPE_SLAVE
+#define SND_TIMER_TYPE_GLOBAL SNDRV_TIMER_TYPE_GLOBAL
+#define SND_TIMER_TYPE_CARD SNDRV_TIMER_TYPE_CARD
+#define SND_TIMER_TYPE_PCM SNDRV_TIMER_TYPE_PCM
+#define SND_TIMER_STYPE_NONE SNDRV_TIMER_STYPE_NONE
+#define SND_TIMER_STYPE_APPLICATION SNDRV_TIMER_STYPE_APPLICATION
+#define SND_TIMER_STYPE_SEQUENCER SNDRV_TIMER_STYPE_SEQUENCER
+#define SND_TIMER_STYPE_OSS_SEQUENCER SNDRV_TIMER_STYPE_OSS_SEQUENCER
+#define SND_TIMER_GLOBAL_SYSTEM SNDRV_TIMER_GLOBAL_SYSTEM
+#define SND_TIMER_GLOBAL_RTC SNDRV_TIMER_GLOBAL_RTC
+#define SND_TIMER_FLG_SLAVE SNDRV_TIMER_FLG_SLAVE
+#define SND_TIMER_PARBIT_FLAGS SNDRV_TIMER_PARBIT_FLAGS
+#define SND_TIMER_PARBIT_TICKS SNDRV_TIMER_PARBIT_TICKS
+#define SND_TIMER_PARBIT_QUEUE_SIZE SNDRV_TIMER_PARBIT_QUEUE_SIZE
+#define SND_TIMER_PSFLG_AUTO SNDRV_TIMER_PSFLG_AUTO
+#define SND_CONTROL_TYPE_NONE SNDRV_CONTROL_TYPE_NONE
+#define SND_CONTROL_TYPE_BOOLEAN SNDRV_CONTROL_TYPE_BOOLEAN
+#define SND_CONTROL_TYPE_INTEGER SNDRV_CONTROL_TYPE_INTEGER
+#define SND_CONTROL_TYPE_ENUMERATED SNDRV_CONTROL_TYPE_ENUMERATED
+#define SND_CONTROL_TYPE_BYTES SNDRV_CONTROL_TYPE_BYTES
+#define SND_CONTROL_TYPE_IEC958 SNDRV_CONTROL_TYPE_IEC958
+#define SND_CONTROL_IFACE_CARD SNDRV_CONTROL_IFACE_CARD
+#define SND_CONTROL_IFACE_HWDEP SNDRV_CONTROL_IFACE_HWDEP
+#define SND_CONTROL_IFACE_MIXER SNDRV_CONTROL_IFACE_MIXER
+#define SND_CONTROL_IFACE_PCM SNDRV_CONTROL_IFACE_PCM
+#define SND_CONTROL_IFACE_RAWMIDI SNDRV_CONTROL_IFACE_RAWMIDI
+#define SND_CONTROL_IFACE_TIMER SNDRV_CONTROL_IFACE_TIMER
+#define SND_CONTROL_IFACE_SEQUENCER SNDRV_CONTROL_IFACE_SEQUENCER
+#define SND_CONTROL_ACCESS_READ SNDRV_CONTROL_ACCESS_READ
+#define SND_CONTROL_ACCESS_WRITE SNDRV_CONTROL_ACCESS_WRITE
+#define SND_CONTROL_ACCESS_READWRITE SNDRV_CONTROL_ACCESS_READWRITE
+#define SND_CONTROL_ACCESS_VOLATILE SNDRV_CONTROL_ACCESS_VOLATILE
+#define SND_CONTROL_ACCESS_INACTIVE SNDRV_CONTROL_ACCESS_INACTIVE
+#define SND_CONTROL_ACCESS_LOCK SNDRV_CONTROL_ACCESS_LOCK
+#define SND_CONTROL_ACCESS_INDIRECT SNDRV_CONTROL_ACCESS_INDIRECT
+#define SND_CTL_EVENT_REBUILD SNDRV_CTL_EVENT_REBUILD
+#define SND_CTL_EVENT_VALUE SNDRV_CTL_EVENT_VALUE
+#define SND_CTL_EVENT_CHANGE SNDRV_CTL_EVENT_CHANGE
+#define SND_CTL_EVENT_ADD SNDRV_CTL_EVENT_ADD
+#define SND_CTL_EVENT_REMOVE SNDRV_CTL_EVENT_REMOVE
+
+/* asequencer.h */
+typedef sndrv_seq_tick_time_t snd_seq_tick_time_t;
+typedef sndrv_seq_position_t snd_seq_position_t;
+typedef sndrv_seq_frequency_t snd_seq_frequency_t;
+typedef sndrv_seq_instr_cluster_t snd_seq_instr_cluster_t;
+typedef enum sndrv_seq_client_type snd_seq_client_type_t;
+typedef enum sndrv_seq_stop_mode snd_seq_stop_mode_t;
+typedef struct sndrv_seq_port_info snd_seq_port_info_t;
+typedef struct sndrv_seq_port_subscribe snd_seq_port_subscribe_t;
+typedef struct sndrv_seq_event snd_seq_event_t;
+typedef struct sndrv_seq_addr snd_seq_addr_t;
+typedef struct sndrv_seq_ev_volume snd_seq_ev_volume_t;
+typedef struct sndrv_seq_ev_loop snd_seq_ev_loop_t;
+typedef struct sndrv_seq_remove_events snd_seq_remove_events_t;
+typedef struct sndrv_seq_query_subs snd_seq_query_subs_t;
+typedef struct sndrv_seq_real_time snd_seq_real_time_t;
+typedef struct sndrv_seq_system_info snd_seq_system_info_t;
+typedef struct sndrv_seq_client_info snd_seq_client_info_t;
+typedef struct sndrv_seq_queue_info snd_seq_queue_info_t;
+typedef struct sndrv_seq_queue_status snd_seq_queue_status_t;
+typedef struct sndrv_seq_queue_tempo snd_seq_queue_tempo_t;
+typedef struct sndrv_seq_queue_owner snd_seq_queue_owner_t;
+typedef struct sndrv_seq_queue_timer snd_seq_queue_timer_t;
+typedef struct sndrv_seq_queue_client snd_seq_queue_client_t;
+typedef struct sndrv_seq_client_pool snd_seq_client_pool_t;
+typedef struct sndrv_seq_instr snd_seq_instr_t;
+typedef struct sndrv_seq_instr_data snd_seq_instr_data_t;
+typedef struct sndrv_seq_instr_free snd_seq_instr_free_t;
+typedef struct sndrv_seq_instr_put snd_seq_instr_put_t;
+typedef struct sndrv_seq_instr_get snd_seq_instr_get_t;
+typedef union sndrv_seq_timestamp snd_seq_timestamp_t;
+
+#define snd_seq_event_bounce_ext_data sndrv_seq_event_bounce_ext_data
+#define snd_seq_ev_is_result_type sndrv_seq_ev_is_result_type
+#define snd_seq_ev_is_channel_type sndrv_seq_ev_is_channel_type
+#define snd_seq_ev_is_note_type sndrv_seq_ev_is_note_type
+#define snd_seq_ev_is_control_type sndrv_seq_ev_is_control_type
+#define snd_seq_ev_is_queue_type sndrv_seq_ev_is_queue_type
+#define snd_seq_ev_is_message_type sndrv_seq_ev_is_message_type
+#define snd_seq_ev_is_sample_type sndrv_seq_ev_is_sample_type
+#define snd_seq_ev_is_user_type sndrv_seq_ev_is_user_type
+#define snd_seq_ev_is_fixed_type sndrv_seq_ev_is_fixed_type
+#define snd_seq_ev_is_instr_type sndrv_seq_ev_is_instr_type
+#define snd_seq_ev_is_variable_type sndrv_seq_ev_is_variable_type
+#define snd_seq_ev_is_varipc_type sndrv_seq_ev_is_varipc_type
+#define snd_seq_ev_is_reserved sndrv_seq_ev_is_reserved
+#define snd_seq_ev_is_direct sndrv_seq_ev_is_direct
+#define snd_seq_ev_is_prior sndrv_seq_ev_is_prior
+#define snd_seq_ev_length_type sndrv_seq_ev_length_type
+#define snd_seq_ev_is_fixed sndrv_seq_ev_is_fixed
+#define snd_seq_ev_is_variable sndrv_seq_ev_is_variable
+#define snd_seq_ev_is_varusr sndrv_seq_ev_is_varusr
+#define snd_seq_ev_is_varipc sndrv_seq_ev_is_varipc
+#define snd_seq_ev_timestamp_type sndrv_seq_ev_timestamp_type
+#define snd_seq_ev_is_tick sndrv_seq_ev_is_tick
+#define snd_seq_ev_is_real sndrv_seq_ev_is_real
+#define snd_seq_ev_timemode_type sndrv_seq_ev_timemode_type
+#define snd_seq_ev_is_abstime sndrv_seq_ev_is_abstime
+#define snd_seq_ev_is_reltime sndrv_seq_ev_is_reltime
+#define snd_seq_queue_sync_port sndrv_seq_queue_sync_port
+#define snd_seq_queue_owner sndrv_seq_queue_owner
+
+#ifdef SNDRV_SEQ_SYNC_SUPPORT
+#define SND_SEQ_SYNC_SUPPORT SNDRV_SEQ_SYNC_SUPPORT
+#endif
+
+#define SND_SEQ_EVENT_SYSTEM SNDRV_SEQ_EVENT_SYSTEM
+#define SND_SEQ_EVENT_RESULT SNDRV_SEQ_EVENT_RESULT
+#define SND_SEQ_EVENT_NOTE SNDRV_SEQ_EVENT_NOTE
+#define SND_SEQ_EVENT_NOTEON SNDRV_SEQ_EVENT_NOTEON
+#define SND_SEQ_EVENT_NOTEOFF SNDRV_SEQ_EVENT_NOTEOFF
+#define SND_SEQ_EVENT_KEYPRESS SNDRV_SEQ_EVENT_KEYPRESS
+#define SND_SEQ_EVENT_CONTROLLER SNDRV_SEQ_EVENT_CONTROLLER
+#define SND_SEQ_EVENT_PGMCHANGE SNDRV_SEQ_EVENT_PGMCHANGE
+#define SND_SEQ_EVENT_CHANPRESS SNDRV_SEQ_EVENT_CHANPRESS
+#define SND_SEQ_EVENT_PITCHBEND SNDRV_SEQ_EVENT_PITCHBEND
+#define SND_SEQ_EVENT_CONTROL14 SNDRV_SEQ_EVENT_CONTROL14
+#define SND_SEQ_EVENT_NONREGPARAM SNDRV_SEQ_EVENT_NONREGPARAM
+#define SND_SEQ_EVENT_REGPARAM SNDRV_SEQ_EVENT_REGPARAM
+#define SND_SEQ_EVENT_SONGPOS SNDRV_SEQ_EVENT_SONGPOS
+#define SND_SEQ_EVENT_SONGSEL SNDRV_SEQ_EVENT_SONGSEL
+#define SND_SEQ_EVENT_QFRAME SNDRV_SEQ_EVENT_QFRAME
+#define SND_SEQ_EVENT_TIMESIGN SNDRV_SEQ_EVENT_TIMESIGN
+#define SND_SEQ_EVENT_KEYSIGN SNDRV_SEQ_EVENT_KEYSIGN
+#define SND_SEQ_EVENT_START SNDRV_SEQ_EVENT_START
+#define SND_SEQ_EVENT_CONTINUE SNDRV_SEQ_EVENT_CONTINUE
+#define SND_SEQ_EVENT_STOP SNDRV_SEQ_EVENT_STOP
+#define SND_SEQ_EVENT_SETPOS_TICK SNDRV_SEQ_EVENT_SETPOS_TICK
+#define SND_SEQ_EVENT_SETPOS_TIME SNDRV_SEQ_EVENT_SETPOS_TIME
+#define SND_SEQ_EVENT_TEMPO SNDRV_SEQ_EVENT_TEMPO
+#define SND_SEQ_EVENT_CLOCK SNDRV_SEQ_EVENT_CLOCK
+#define SND_SEQ_EVENT_TICK SNDRV_SEQ_EVENT_TICK
+#define SND_SEQ_EVENT_SYNC SNDRV_SEQ_EVENT_SYNC
+#define SND_SEQ_EVENT_SYNC_POS SNDRV_SEQ_EVENT_SYNC_POS
+#define SND_SEQ_EVENT_TUNE_REQUEST SNDRV_SEQ_EVENT_TUNE_REQUEST
+#define SND_SEQ_EVENT_RESET SNDRV_SEQ_EVENT_RESET
+#define SND_SEQ_EVENT_SENSING SNDRV_SEQ_EVENT_SENSING
+#define SND_SEQ_EVENT_ECHO SNDRV_SEQ_EVENT_ECHO
+#define SND_SEQ_EVENT_OSS SNDRV_SEQ_EVENT_OSS
+#define SND_SEQ_EVENT_CLIENT_START SNDRV_SEQ_EVENT_CLIENT_START
+#define SND_SEQ_EVENT_CLIENT_EXIT SNDRV_SEQ_EVENT_CLIENT_EXIT
+#define SND_SEQ_EVENT_CLIENT_CHANGE SNDRV_SEQ_EVENT_CLIENT_CHANGE
+#define SND_SEQ_EVENT_PORT_START SNDRV_SEQ_EVENT_PORT_START
+#define SND_SEQ_EVENT_PORT_EXIT SNDRV_SEQ_EVENT_PORT_EXIT
+#define SND_SEQ_EVENT_PORT_CHANGE SNDRV_SEQ_EVENT_PORT_CHANGE
+#define SND_SEQ_EVENT_PORT_SUBSCRIBED SNDRV_SEQ_EVENT_PORT_SUBSCRIBED
+#define SND_SEQ_EVENT_PORT_USED SNDRV_SEQ_EVENT_PORT_USED
+#define SND_SEQ_EVENT_PORT_UNSUBSCRIBED SNDRV_SEQ_EVENT_PORT_UNSUBSCRIBED
+#define SND_SEQ_EVENT_PORT_UNUSED SNDRV_SEQ_EVENT_PORT_UNUSED
+#define SND_SEQ_EVENT_SAMPLE SNDRV_SEQ_EVENT_SAMPLE
+#define SND_SEQ_EVENT_SAMPLE_CLUSTER SNDRV_SEQ_EVENT_SAMPLE_CLUSTER
+#define SND_SEQ_EVENT_SAMPLE_START SNDRV_SEQ_EVENT_SAMPLE_START
+#define SND_SEQ_EVENT_SAMPLE_STOP SNDRV_SEQ_EVENT_SAMPLE_STOP
+#define SND_SEQ_EVENT_SAMPLE_FREQ SNDRV_SEQ_EVENT_SAMPLE_FREQ
+#define SND_SEQ_EVENT_SAMPLE_VOLUME SNDRV_SEQ_EVENT_SAMPLE_VOLUME
+#define SND_SEQ_EVENT_SAMPLE_LOOP SNDRV_SEQ_EVENT_SAMPLE_LOOP
+#define SND_SEQ_EVENT_SAMPLE_POSITION SNDRV_SEQ_EVENT_SAMPLE_POSITION
+#define SND_SEQ_EVENT_SAMPLE_PRIVATE1 SNDRV_SEQ_EVENT_SAMPLE_PRIVATE1
+#define SND_SEQ_EVENT_USR0 SNDRV_SEQ_EVENT_USR0
+#define SND_SEQ_EVENT_USR1 SNDRV_SEQ_EVENT_USR1
+#define SND_SEQ_EVENT_USR2 SNDRV_SEQ_EVENT_USR2
+#define SND_SEQ_EVENT_USR3 SNDRV_SEQ_EVENT_USR3
+#define SND_SEQ_EVENT_USR4 SNDRV_SEQ_EVENT_USR4
+#define SND_SEQ_EVENT_USR5 SNDRV_SEQ_EVENT_USR5
+#define SND_SEQ_EVENT_USR6 SNDRV_SEQ_EVENT_USR6
+#define SND_SEQ_EVENT_USR7 SNDRV_SEQ_EVENT_USR7
+#define SND_SEQ_EVENT_USR8 SNDRV_SEQ_EVENT_USR8
+#define SND_SEQ_EVENT_USR9 SNDRV_SEQ_EVENT_USR9
+#define SND_SEQ_EVENT_INSTR_BEGIN SNDRV_SEQ_EVENT_INSTR_BEGIN
+#define SND_SEQ_EVENT_INSTR_END SNDRV_SEQ_EVENT_INSTR_END
+#define SND_SEQ_EVENT_INSTR_INFO SNDRV_SEQ_EVENT_INSTR_INFO
+#define SND_SEQ_EVENT_INSTR_INFO_RESULT SNDRV_SEQ_EVENT_INSTR_INFO_RESULT
+#define SND_SEQ_EVENT_INSTR_FINFO SNDRV_SEQ_EVENT_INSTR_FINFO
+#define SND_SEQ_EVENT_INSTR_FINFO_RESULT SNDRV_SEQ_EVENT_INSTR_FINFO_RESULT
+#define SND_SEQ_EVENT_INSTR_RESET SNDRV_SEQ_EVENT_INSTR_RESET
+#define SND_SEQ_EVENT_INSTR_STATUS SNDRV_SEQ_EVENT_INSTR_STATUS
+#define SND_SEQ_EVENT_INSTR_STATUS_RESULT SNDRV_SEQ_EVENT_INSTR_STATUS_RESULT
+#define SND_SEQ_EVENT_INSTR_PUT SNDRV_SEQ_EVENT_INSTR_PUT
+#define SND_SEQ_EVENT_INSTR_GET SNDRV_SEQ_EVENT_INSTR_GET
+#define SND_SEQ_EVENT_INSTR_GET_RESULT SNDRV_SEQ_EVENT_INSTR_GET_RESULT
+#define SND_SEQ_EVENT_INSTR_FREE SNDRV_SEQ_EVENT_INSTR_FREE
+#define SND_SEQ_EVENT_INSTR_LIST SNDRV_SEQ_EVENT_INSTR_LIST
+#define SND_SEQ_EVENT_INSTR_LIST_RESULT SNDRV_SEQ_EVENT_INSTR_LIST_RESULT
+#define SND_SEQ_EVENT_INSTR_CLUSTER SNDRV_SEQ_EVENT_INSTR_CLUSTER
+#define SND_SEQ_EVENT_INSTR_CLUSTER_GET SNDRV_SEQ_EVENT_INSTR_CLUSTER_GET
+#define SND_SEQ_EVENT_INSTR_CLUSTER_RESULT SNDRV_SEQ_EVENT_INSTR_CLUSTER_RESULT
+#define SND_SEQ_EVENT_INSTR_CHANGE SNDRV_SEQ_EVENT_INSTR_CHANGE
+#define SND_SEQ_EVENT_LENGTH_VARIABLE SNDRV_SEQ_EVENT_LENGTH_VARIABLE
+#define SND_SEQ_EVENT_SYSEX SNDRV_SEQ_EVENT_SYSEX
+#define SND_SEQ_EVENT_BOUNCE SNDRV_SEQ_EVENT_BOUNCE
+#define SND_SEQ_EVENT_USR_VAR0 SNDRV_SEQ_EVENT_USR_VAR0
+#define SND_SEQ_EVENT_USR_VAR1 SNDRV_SEQ_EVENT_USR_VAR1
+#define SND_SEQ_EVENT_USR_VAR2 SNDRV_SEQ_EVENT_USR_VAR2
+#define SND_SEQ_EVENT_USR_VAR3 SNDRV_SEQ_EVENT_USR_VAR3
+#define SND_SEQ_EVENT_USR_VAR4 SNDRV_SEQ_EVENT_USR_VAR4
+#define SND_SEQ_EVENT_LENGTH_VARIPC SNDRV_SEQ_EVENT_LENGTH_VARIPC
+#define SND_SEQ_EVENT_IPCSHM SNDRV_SEQ_EVENT_IPCSHM
+#define SND_SEQ_EVENT_USR_VARIPC0 SNDRV_SEQ_EVENT_USR_VARIPC0
+#define SND_SEQ_EVENT_USR_VARIPC1 SNDRV_SEQ_EVENT_USR_VARIPC1
+#define SND_SEQ_EVENT_USR_VARIPC2 SNDRV_SEQ_EVENT_USR_VARIPC2
+#define SND_SEQ_EVENT_USR_VARIPC3 SNDRV_SEQ_EVENT_USR_VARIPC3
+#define SND_SEQ_EVENT_USR_VARIPC4 SNDRV_SEQ_EVENT_USR_VARIPC4
+#define SND_SEQ_EVENT_KERNEL_ERROR SNDRV_SEQ_EVENT_KERNEL_ERROR
+#define SND_SEQ_EVENT_KERNEL_QUOTE SNDRV_SEQ_EVENT_KERNEL_QUOTE
+#define SND_SEQ_EVENT_NONE SNDRV_SEQ_EVENT_NONE
+#define SND_SEQ_ADDRESS_UNKNOWN SNDRV_SEQ_ADDRESS_UNKNOWN
+#define SND_SEQ_ADDRESS_SUBSCRIBERS SNDRV_SEQ_ADDRESS_SUBSCRIBERS
+#define SND_SEQ_ADDRESS_BROADCAST SNDRV_SEQ_ADDRESS_BROADCAST
+#define SND_SEQ_QUEUE_DIRECT SNDRV_SEQ_QUEUE_DIRECT
+#define SND_SEQ_TIME_STAMP_TICK SNDRV_SEQ_TIME_STAMP_TICK
+#define SND_SEQ_TIME_STAMP_REAL SNDRV_SEQ_TIME_STAMP_REAL
+#define SND_SEQ_TIME_STAMP_MASK SNDRV_SEQ_TIME_STAMP_MASK
+#define SND_SEQ_TIME_MODE_ABS SNDRV_SEQ_TIME_MODE_ABS
+#define SND_SEQ_TIME_MODE_REL SNDRV_SEQ_TIME_MODE_REL
+#define SND_SEQ_TIME_MODE_MASK SNDRV_SEQ_TIME_MODE_MASK
+#define SND_SEQ_EVENT_LENGTH_FIXED SNDRV_SEQ_EVENT_LENGTH_FIXED
+#define SND_SEQ_EVENT_LENGTH_VARIABLE SNDRV_SEQ_EVENT_LENGTH_VARIABLE
+#define SND_SEQ_EVENT_LENGTH_VARUSR SNDRV_SEQ_EVENT_LENGTH_VARUSR
+#define SND_SEQ_EVENT_LENGTH_VARIPC SNDRV_SEQ_EVENT_LENGTH_VARIPC
+#define SND_SEQ_EVENT_LENGTH_MASK SNDRV_SEQ_EVENT_LENGTH_MASK
+#define SND_SEQ_PRIORITY_NORMAL SNDRV_SEQ_PRIORITY_NORMAL
+#define SND_SEQ_PRIORITY_HIGH SNDRV_SEQ_PRIORITY_HIGH
+#define SND_SEQ_PRIORITY_MASK SNDRV_SEQ_PRIORITY_MASK
+#define SND_SEQ_EVENT_NOTE SNDRV_SEQ_EVENT_NOTE
+#define SND_SEQ_EVENT_NOTE SNDRV_SEQ_EVENT_NOTE
+#define SND_SEQ_QUEUE_DIRECT SNDRV_SEQ_QUEUE_DIRECT
+#define SND_SEQ_PRIORITY_MASK SNDRV_SEQ_PRIORITY_MASK
+#define SND_SEQ_EVENT_LENGTH_MASK SNDRV_SEQ_EVENT_LENGTH_MASK
+#define SND_SEQ_EVENT_LENGTH_FIXED SNDRV_SEQ_EVENT_LENGTH_FIXED
+#define SND_SEQ_EVENT_LENGTH_VARIABLE SNDRV_SEQ_EVENT_LENGTH_VARIABLE
+#define SND_SEQ_EVENT_LENGTH_VARUSR SNDRV_SEQ_EVENT_LENGTH_VARUSR
+#define SND_SEQ_EVENT_LENGTH_VARIPC SNDRV_SEQ_EVENT_LENGTH_VARIPC
+#define SND_SEQ_TIME_STAMP_MASK SNDRV_SEQ_TIME_STAMP_MASK
+#define SND_SEQ_TIME_STAMP_TICK SNDRV_SEQ_TIME_STAMP_TICK
+#define SND_SEQ_TIME_STAMP_REAL SNDRV_SEQ_TIME_STAMP_REAL
+#define SND_SEQ_TIME_MODE_MASK SNDRV_SEQ_TIME_MODE_MASK
+#define SND_SEQ_TIME_MODE_ABS SNDRV_SEQ_TIME_MODE_ABS
+#define SND_SEQ_TIME_MODE_REL SNDRV_SEQ_TIME_MODE_REL
+#define SND_SEQ_CLIENT_SYSTEM SNDRV_SEQ_CLIENT_SYSTEM
+#define SND_SEQ_CLIENT_DUMMY SNDRV_SEQ_CLIENT_DUMMY
+#define SND_SEQ_CLIENT_OSS SNDRV_SEQ_CLIENT_OSS
+#define SND_SEQ_FILTER_BROADCAST SNDRV_SEQ_FILTER_BROADCAST
+#define SND_SEQ_FILTER_MULTICAST SNDRV_SEQ_FILTER_MULTICAST
+#define SND_SEQ_FILTER_BOUNCE SNDRV_SEQ_FILTER_BOUNCE
+#define SND_SEQ_FILTER_USE_EVENT SNDRV_SEQ_FILTER_USE_EVENT
+#define SND_SEQ_REMOVE_DEST SNDRV_SEQ_REMOVE_DEST
+#define SND_SEQ_REMOVE_DEST_CHANNEL SNDRV_SEQ_REMOVE_DEST_CHANNEL
+#define SND_SEQ_REMOVE_TIME_BEFORE SNDRV_SEQ_REMOVE_TIME_BEFORE
+#define SND_SEQ_REMOVE_TIME_AFTER SNDRV_SEQ_REMOVE_TIME_AFTER
+#define SND_SEQ_REMOVE_EVENT_TYPE SNDRV_SEQ_REMOVE_EVENT_TYPE
+#define SND_SEQ_REMOVE_IGNORE_OFF SNDRV_SEQ_REMOVE_IGNORE_OFF
+#define SND_SEQ_REMOVE_TAG_MATCH SNDRV_SEQ_REMOVE_TAG_MATCH
+#define SND_SEQ_PORT_SYSTEM_TIMER SNDRV_SEQ_PORT_SYSTEM_TIMER
+#define SND_SEQ_PORT_SYSTEM_ANNOUNCE SNDRV_SEQ_PORT_SYSTEM_ANNOUNCE
+#define SND_SEQ_PORT_CAP_READ SNDRV_SEQ_PORT_CAP_READ
+#define SND_SEQ_PORT_CAP_WRITE SNDRV_SEQ_PORT_CAP_WRITE
+#define SND_SEQ_PORT_CAP_SYNC_READ SNDRV_SEQ_PORT_CAP_SYNC_READ
+#define SND_SEQ_PORT_CAP_SYNC_WRITE SNDRV_SEQ_PORT_CAP_SYNC_WRITE
+#define SND_SEQ_PORT_CAP_DUPLEX SNDRV_SEQ_PORT_CAP_DUPLEX
+#define SND_SEQ_PORT_CAP_SUBS_READ SNDRV_SEQ_PORT_CAP_SUBS_READ
+#define SND_SEQ_PORT_CAP_SUBS_WRITE SNDRV_SEQ_PORT_CAP_SUBS_WRITE
+#define SND_SEQ_PORT_CAP_NO_EXPORT SNDRV_SEQ_PORT_CAP_NO_EXPORT
+#define SND_SEQ_PORT_TYPE_SPECIFIC SNDRV_SEQ_PORT_TYPE_SPECIFIC
+#define SND_SEQ_PORT_TYPE_MIDI_GENERIC SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC
+#define SND_SEQ_PORT_TYPE_MIDI_GM SNDRV_SEQ_PORT_TYPE_MIDI_GM
+#define SND_SEQ_PORT_TYPE_MIDI_GS SNDRV_SEQ_PORT_TYPE_MIDI_GS
+#define SND_SEQ_PORT_TYPE_MIDI_XG SNDRV_SEQ_PORT_TYPE_MIDI_XG
+#define SND_SEQ_PORT_TYPE_MIDI_MT32 SNDRV_SEQ_PORT_TYPE_MIDI_MT32
+#define SND_SEQ_PORT_TYPE_SYNTH SNDRV_SEQ_PORT_TYPE_SYNTH
+#define SND_SEQ_PORT_TYPE_DIRECT_SAMPLE SNDRV_SEQ_PORT_TYPE_DIRECT_SAMPLE
+#define SND_SEQ_PORT_TYPE_SAMPLE SNDRV_SEQ_PORT_TYPE_SAMPLE
+#define SND_SEQ_PORT_TYPE_APPLICATION SNDRV_SEQ_PORT_TYPE_APPLICATION
+#define SND_SEQ_GROUP_SYSTEM SNDRV_SEQ_GROUP_SYSTEM
+#define SND_SEQ_GROUP_DEVICE SNDRV_SEQ_GROUP_DEVICE
+#define SND_SEQ_GROUP_APPLICATION SNDRV_SEQ_GROUP_APPLICATION
+#define SND_SEQ_PORT_FLG_GIVEN_PORT SNDRV_SEQ_PORT_FLG_GIVEN_PORT
+#define SND_SEQ_QUEUE_FLG_SYNC SNDRV_SEQ_QUEUE_FLG_SYNC
+#define SND_SEQ_QUEUE_FLG_SYNC_LOST SNDRV_SEQ_QUEUE_FLG_SYNC_LOST
+#define SND_SEQ_SYNC_TICK SNDRV_SEQ_SYNC_TICK
+#define SND_SEQ_SYNC_TIME SNDRV_SEQ_SYNC_TIME
+#define SND_SEQ_SYNC_MODE SNDRV_SEQ_SYNC_MODE
+#define SND_SEQ_SYNC_FMT_PRIVATE_CLOCK SNDRV_SEQ_SYNC_FMT_PRIVATE_CLOCK
+#define SND_SEQ_SYNC_FMT_PRIVATE_TIME SNDRV_SEQ_SYNC_FMT_PRIVATE_TIME
+#define SND_SEQ_SYNC_FMT_MIDI_CLOCK SNDRV_SEQ_SYNC_FMT_MIDI_CLOCK
+#define SND_SEQ_SYNC_FMT_MTC SNDRV_SEQ_SYNC_FMT_MTC
+#define SND_SEQ_SYNC_FMT_DTL SNDRV_SEQ_SYNC_FMT_DTL
+#define SND_SEQ_SYNC_FMT_SMPTE SNDRV_SEQ_SYNC_FMT_SMPTE
+#define SND_SEQ_SYNC_FMT_MIDI_TICK SNDRV_SEQ_SYNC_FMT_MIDI_TICK
+#define SND_SEQ_SYNC_FPS_24 SNDRV_SEQ_SYNC_FPS_24
+#define SND_SEQ_SYNC_FPS_25 SNDRV_SEQ_SYNC_FPS_25
+#define SND_SEQ_SYNC_FPS_30_DP SNDRV_SEQ_SYNC_FPS_30_DP
+#define SND_SEQ_SYNC_FPS_30_NDP SNDRV_SEQ_SYNC_FPS_30_NDP
+#define SND_SEQ_TIMER_ALSA SNDRV_SEQ_TIMER_ALSA
+#define SND_SEQ_TIMER_MIDI_CLOCK SNDRV_SEQ_TIMER_MIDI_CLOCK
+#define SND_SEQ_TIMER_MIDI_TICK SNDRV_SEQ_TIMER_MIDI_TICK
+#define SND_SEQ_QUERY_SUBS_READ SNDRV_SEQ_QUERY_SUBS_READ
+#define SND_SEQ_QUERY_SUBS_WRITE SNDRV_SEQ_QUERY_SUBS_WRITE
+#define SND_SEQ_INSTR_ATYPE_DATA SNDRV_SEQ_INSTR_ATYPE_DATA
+#define SND_SEQ_INSTR_ATYPE_ALIAS SNDRV_SEQ_INSTR_ATYPE_ALIAS
+#define SND_SEQ_INSTR_ID_DLS1 SNDRV_SEQ_INSTR_ID_DLS1
+#define SND_SEQ_INSTR_ID_DLS2 SNDRV_SEQ_INSTR_ID_DLS2
+#define SND_SEQ_INSTR_ID_SIMPLE SNDRV_SEQ_INSTR_ID_SIMPLE
+#define SND_SEQ_INSTR_ID_SOUNDFONT SNDRV_SEQ_INSTR_ID_SOUNDFONT
+#define SND_SEQ_INSTR_ID_GUS_PATCH SNDRV_SEQ_INSTR_ID_GUS_PATCH
+#define SND_SEQ_INSTR_ID_INTERWAVE SNDRV_SEQ_INSTR_ID_INTERWAVE
+#define SND_SEQ_INSTR_ID_OPL2_3 SNDRV_SEQ_INSTR_ID_OPL2_3
+#define SND_SEQ_INSTR_ID_OPL4 SNDRV_SEQ_INSTR_ID_OPL4
+#define SND_SEQ_INSTR_TYPE0_DLS1 SNDRV_SEQ_INSTR_TYPE0_DLS1
+#define SND_SEQ_INSTR_TYPE0_DLS2 SNDRV_SEQ_INSTR_TYPE0_DLS2
+#define SND_SEQ_INSTR_TYPE1_SIMPLE SNDRV_SEQ_INSTR_TYPE1_SIMPLE
+#define SND_SEQ_INSTR_TYPE1_SOUNDFONT SNDRV_SEQ_INSTR_TYPE1_SOUNDFONT
+#define SND_SEQ_INSTR_TYPE1_GUS_PATCH SNDRV_SEQ_INSTR_TYPE1_GUS_PATCH
+#define SND_SEQ_INSTR_TYPE1_INTERWAVE SNDRV_SEQ_INSTR_TYPE1_INTERWAVE
+#define SND_SEQ_INSTR_TYPE2_OPL2_3 SNDRV_SEQ_INSTR_TYPE2_OPL2_3
+#define SND_SEQ_INSTR_TYPE2_OPL4 SNDRV_SEQ_INSTR_TYPE2_OPL4
+#define SND_SEQ_INSTR_PUT_CMD_CREATE SNDRV_SEQ_INSTR_PUT_CMD_CREATE
+#define SND_SEQ_INSTR_PUT_CMD_REPLACE SNDRV_SEQ_INSTR_PUT_CMD_REPLACE
+#define SND_SEQ_INSTR_PUT_CMD_MODIFY SNDRV_SEQ_INSTR_PUT_CMD_MODIFY
+#define SND_SEQ_INSTR_PUT_CMD_ADD SNDRV_SEQ_INSTR_PUT_CMD_ADD
+#define SND_SEQ_INSTR_PUT_CMD_REMOVE SNDRV_SEQ_INSTR_PUT_CMD_REMOVE
+#define SND_SEQ_INSTR_GET_CMD_FULL SNDRV_SEQ_INSTR_GET_CMD_FULL
+#define SND_SEQ_INSTR_GET_CMD_PARTIAL SNDRV_SEQ_INSTR_GET_CMD_PARTIAL
+#define SND_SEQ_INSTR_QUERY_FOLLOW_ALIAS SNDRV_SEQ_INSTR_QUERY_FOLLOW_ALIAS
+#define SND_SEQ_INSTR_FREE_CMD_ALL SNDRV_SEQ_INSTR_FREE_CMD_ALL
+#define SND_SEQ_INSTR_FREE_CMD_PRIVATE SNDRV_SEQ_INSTR_FREE_CMD_PRIVATE
+#define SND_SEQ_INSTR_FREE_CMD_CLUSTER SNDRV_SEQ_INSTR_FREE_CMD_CLUSTER
+#define SND_SEQ_INSTR_FREE_CMD_SINGLE SNDRV_SEQ_INSTR_FREE_CMD_SINGLE
#include "asoundlib.h"
#include "control_local.h"
-#define SND_FILE_CONTROL "/dev/snd/controlC%i"
-#define SND_CTL_VERSION_MAX SND_PROTOCOL_VERSION(2, 0, 0)
+#define SNDRV_FILE_CONTROL "/dev/snd/controlC%i"
+#define SNDRV_CTL_VERSION_MAX SNDRV_PROTOCOL_VERSION(2, 0, 0)
typedef struct {
int card;
static int snd_ctl_hw_hw_info(snd_ctl_t *handle, snd_ctl_hw_info_t *info)
{
snd_ctl_hw_t *hw = handle->private;
- if (ioctl(hw->fd, SND_CTL_IOCTL_HW_INFO, info) < 0)
+ if (ioctl(hw->fd, SNDRV_CTL_IOCTL_HW_INFO, info) < 0)
return -errno;
return 0;
}
static int snd_ctl_hw_clist(snd_ctl_t *handle, snd_control_list_t *list)
{
snd_ctl_hw_t *hw = handle->private;
- if (ioctl(hw->fd, SND_CTL_IOCTL_CONTROL_LIST, list) < 0)
+ if (ioctl(hw->fd, SNDRV_CTL_IOCTL_CONTROL_LIST, list) < 0)
return -errno;
return 0;
}
static int snd_ctl_hw_cinfo(snd_ctl_t *handle, snd_control_info_t *info)
{
snd_ctl_hw_t *hw = handle->private;
- if (ioctl(hw->fd, SND_CTL_IOCTL_CONTROL_INFO, info) < 0)
+ if (ioctl(hw->fd, SNDRV_CTL_IOCTL_CONTROL_INFO, info) < 0)
return -errno;
return 0;
}
static int snd_ctl_hw_cread(snd_ctl_t *handle, snd_control_t *control)
{
snd_ctl_hw_t *hw = handle->private;
- if (ioctl(hw->fd, SND_CTL_IOCTL_CONTROL_READ, control) < 0)
+ if (ioctl(hw->fd, SNDRV_CTL_IOCTL_CONTROL_READ, control) < 0)
return -errno;
return 0;
}
static int snd_ctl_hw_cwrite(snd_ctl_t *handle, snd_control_t *control)
{
snd_ctl_hw_t *hw = handle->private;
- if (ioctl(hw->fd, SND_CTL_IOCTL_CONTROL_WRITE, control) < 0)
+ if (ioctl(hw->fd, SNDRV_CTL_IOCTL_CONTROL_WRITE, control) < 0)
return -errno;
return 0;
}
static int snd_ctl_hw_hwdep_next_device(snd_ctl_t *handle, int * device)
{
snd_ctl_hw_t *hw = handle->private;
- if (ioctl(hw->fd, SND_CTL_IOCTL_HWDEP_NEXT_DEVICE, device) < 0)
+ if (ioctl(hw->fd, SNDRV_CTL_IOCTL_HWDEP_NEXT_DEVICE, device) < 0)
return -errno;
return 0;
}
static int snd_ctl_hw_hwdep_info(snd_ctl_t *handle, snd_hwdep_info_t * info)
{
snd_ctl_hw_t *hw = handle->private;
- if (ioctl(hw->fd, SND_CTL_IOCTL_HWDEP_INFO, info) < 0)
+ if (ioctl(hw->fd, SNDRV_CTL_IOCTL_HWDEP_INFO, info) < 0)
return -errno;
return 0;
}
static int snd_ctl_hw_pcm_next_device(snd_ctl_t *handle, int * device)
{
snd_ctl_hw_t *hw = handle->private;
- if (ioctl(hw->fd, SND_CTL_IOCTL_PCM_NEXT_DEVICE, device) < 0)
+ if (ioctl(hw->fd, SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE, device) < 0)
return -errno;
return 0;
}
static int snd_ctl_hw_pcm_info(snd_ctl_t *handle, snd_pcm_info_t * info)
{
snd_ctl_hw_t *hw = handle->private;
- if (ioctl(hw->fd, SND_CTL_IOCTL_PCM_INFO, info) < 0)
+ if (ioctl(hw->fd, SNDRV_CTL_IOCTL_PCM_INFO, info) < 0)
return -errno;
return 0;
}
static int snd_ctl_hw_pcm_prefer_subdevice(snd_ctl_t *handle, int subdev)
{
snd_ctl_hw_t *hw = handle->private;
- if (ioctl(hw->fd, SND_CTL_IOCTL_PCM_PREFER_SUBDEVICE, &subdev) < 0)
+ if (ioctl(hw->fd, SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE, &subdev) < 0)
return -errno;
return 0;
}
static int snd_ctl_hw_rawmidi_next_device(snd_ctl_t *handle, int * device)
{
snd_ctl_hw_t *hw = handle->private;
- if (ioctl(hw->fd, SND_CTL_IOCTL_RAWMIDI_NEXT_DEVICE, device) < 0)
+ if (ioctl(hw->fd, SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE, device) < 0)
return -errno;
return 0;
}
static int snd_ctl_hw_rawmidi_info(snd_ctl_t *handle, snd_rawmidi_info_t * info)
{
snd_ctl_hw_t *hw = handle->private;
- if (ioctl(hw->fd, SND_CTL_IOCTL_RAWMIDI_INFO, info) < 0)
+ if (ioctl(hw->fd, SNDRV_CTL_IOCTL_RAWMIDI_INFO, info) < 0)
return -errno;
return 0;
}
static int snd_ctl_hw_rawmidi_prefer_subdevice(snd_ctl_t *handle, int subdev)
{
snd_ctl_hw_t *hw = handle->private;
- if (ioctl(hw->fd, SND_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE, &subdev) < 0)
+ if (ioctl(hw->fd, SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE, &subdev) < 0)
return -errno;
return 0;
}
*handle = NULL;
assert(card >= 0 && card < 32);
- sprintf(filename, SND_FILE_CONTROL, card);
+ sprintf(filename, SNDRV_FILE_CONTROL, card);
if ((fd = open(filename, O_RDWR)) < 0) {
snd_card_load(card);
if ((fd = open(filename, O_RDWR)) < 0)
return -errno;
}
- if (ioctl(fd, SND_CTL_IOCTL_PVERSION, &ver) < 0) {
+ if (ioctl(fd, SNDRV_CTL_IOCTL_PVERSION, &ver) < 0) {
close(fd);
return -errno;
}
- if (SND_PROTOCOL_INCOMPATIBLE(ver, SND_CTL_VERSION_MAX)) {
+ if (SNDRV_PROTOCOL_INCOMPATIBLE(ver, SNDRV_CTL_VERSION_MAX)) {
close(fd);
return -SND_ERROR_INCOMPATIBLE_VERSION;
}
volatile snd_ctl_shm_ctrl_t *ctrl = shm->ctrl;
int err;
// ctrl->u.hw_info = *info;
- ctrl->cmd = SND_CTL_IOCTL_HW_INFO;
+ ctrl->cmd = SNDRV_CTL_IOCTL_HW_INFO;
err = snd_ctl_shm_action(ctl);
if (err < 0)
return err;
if (bytes > maxsize)
return -EINVAL;
ctrl->u.clist = *list;
- ctrl->cmd = SND_CTL_IOCTL_CONTROL_LIST;
+ ctrl->cmd = SNDRV_CTL_IOCTL_CONTROL_LIST;
err = snd_ctl_shm_action(ctl);
if (err < 0)
return err;
volatile snd_ctl_shm_ctrl_t *ctrl = shm->ctrl;
int err;
ctrl->u.cinfo = *info;
- ctrl->cmd = SND_CTL_IOCTL_CONTROL_INFO;
+ ctrl->cmd = SNDRV_CTL_IOCTL_CONTROL_INFO;
err = snd_ctl_shm_action(ctl);
if (err < 0)
return err;
volatile snd_ctl_shm_ctrl_t *ctrl = shm->ctrl;
int err;
ctrl->u.cread = *control;
- ctrl->cmd = SND_CTL_IOCTL_CONTROL_READ;
+ ctrl->cmd = SNDRV_CTL_IOCTL_CONTROL_READ;
err = snd_ctl_shm_action(ctl);
if (err < 0)
return err;
volatile snd_ctl_shm_ctrl_t *ctrl = shm->ctrl;
int err;
ctrl->u.cwrite = *control;
- ctrl->cmd = SND_CTL_IOCTL_CONTROL_WRITE;
+ ctrl->cmd = SNDRV_CTL_IOCTL_CONTROL_WRITE;
err = snd_ctl_shm_action(ctl);
if (err < 0)
return err;
volatile snd_ctl_shm_ctrl_t *ctrl = shm->ctrl;
int err;
ctrl->u.device = *device;
- ctrl->cmd = SND_CTL_IOCTL_HWDEP_NEXT_DEVICE;
+ ctrl->cmd = SNDRV_CTL_IOCTL_HWDEP_NEXT_DEVICE;
err = snd_ctl_shm_action(ctl);
if (err < 0)
return err;
volatile snd_ctl_shm_ctrl_t *ctrl = shm->ctrl;
int err;
ctrl->u.hwdep_info = *info;
- ctrl->cmd = SND_CTL_IOCTL_HWDEP_INFO;
+ ctrl->cmd = SNDRV_CTL_IOCTL_HWDEP_INFO;
err = snd_ctl_shm_action(ctl);
if (err < 0)
return err;
volatile snd_ctl_shm_ctrl_t *ctrl = shm->ctrl;
int err;
ctrl->u.device = *device;
- ctrl->cmd = SND_CTL_IOCTL_PCM_NEXT_DEVICE;
+ ctrl->cmd = SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE;
err = snd_ctl_shm_action(ctl);
if (err < 0)
return err;
volatile snd_ctl_shm_ctrl_t *ctrl = shm->ctrl;
int err;
ctrl->u.pcm_info = *info;
- ctrl->cmd = SND_CTL_IOCTL_PCM_INFO;
+ ctrl->cmd = SNDRV_CTL_IOCTL_PCM_INFO;
err = snd_ctl_shm_action(ctl);
if (err < 0)
return err;
volatile snd_ctl_shm_ctrl_t *ctrl = shm->ctrl;
int err;
ctrl->u.pcm_prefer_subdevice = subdev;
- ctrl->cmd = SND_CTL_IOCTL_PCM_PREFER_SUBDEVICE;
+ ctrl->cmd = SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE;
err = snd_ctl_shm_action(ctl);
if (err < 0)
return err;
volatile snd_ctl_shm_ctrl_t *ctrl = shm->ctrl;
int err;
ctrl->u.device = *device;
- ctrl->cmd = SND_CTL_IOCTL_RAWMIDI_NEXT_DEVICE;
+ ctrl->cmd = SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE;
err = snd_ctl_shm_action(ctl);
if (err < 0)
return err;
volatile snd_ctl_shm_ctrl_t *ctrl = shm->ctrl;
int err;
ctrl->u.rawmidi_info = *info;
- ctrl->cmd = SND_CTL_IOCTL_RAWMIDI_INFO;
+ ctrl->cmd = SNDRV_CTL_IOCTL_RAWMIDI_INFO;
err = snd_ctl_shm_action(ctl);
if (err < 0)
return err;
volatile snd_ctl_shm_ctrl_t *ctrl = shm->ctrl;
int err;
ctrl->u.rawmidi_prefer_subdevice = subdev;
- ctrl->cmd = SND_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE;
+ ctrl->cmd = SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE;
err = snd_ctl_shm_action(ctl);
if (err < 0)
return err;
#include <sys/ioctl.h>
#include "asoundlib.h"
-#define SND_FILE_HWDEP "/dev/snd/hwC%iD%i"
-#define SND_HWDEP_VERSION_MAX SND_PROTOCOL_VERSION(1, 0, 0)
+#define SNDRV_FILE_HWDEP "/dev/snd/hwC%iD%i"
+#define SNDRV_HWDEP_VERSION_MAX SNDRV_PROTOCOL_VERSION(1, 0, 0)
struct _snd_hwdep {
int card;
if (card < 0 || card >= 32)
return -EINVAL;
- sprintf(filename, SND_FILE_HWDEP, card, device);
+ sprintf(filename, SNDRV_FILE_HWDEP, card, device);
if ((fd = open(filename, mode)) < 0) {
snd_card_load(card);
if ((fd = open(filename, mode)) < 0)
return -errno;
}
- if (ioctl(fd, SND_HWDEP_IOCTL_PVERSION, &ver) < 0) {
+ if (ioctl(fd, SNDRV_HWDEP_IOCTL_PVERSION, &ver) < 0) {
close(fd);
return -errno;
}
- if (SND_PROTOCOL_INCOMPATIBLE(ver, SND_HWDEP_VERSION_MAX)) {
+ if (SNDRV_PROTOCOL_INCOMPATIBLE(ver, SNDRV_HWDEP_VERSION_MAX)) {
close(fd);
return -SND_ERROR_INCOMPATIBLE_VERSION;
}
{
if (!hwdep || !info)
return -EINVAL;
- if (ioctl(hwdep->fd, SND_HWDEP_IOCTL_INFO, info) < 0)
+ if (ioctl(hwdep->fd, SNDRV_HWDEP_IOCTL_INFO, info) < 0)
return -errno;
return 0;
}
int fd2 = snd_pcm_link_descriptor(pcm2);
if (fd1 < 0 || fd2 < 0)
return -ENOSYS;
- if (ioctl(fd1, SND_PCM_IOCTL_LINK, fd2) < 0) {
- SYSERR("SND_PCM_IOCTL_LINK failed");
+ if (ioctl(fd1, SNDRV_PCM_IOCTL_LINK, fd2) < 0) {
+ SYSERR("SNDRV_PCM_IOCTL_LINK failed");
return -errno;
}
return 0;
default:
return -ENOSYS;
}
- if (ioctl(fd, SND_PCM_IOCTL_UNLINK) < 0) {
- SYSERR("SND_PCM_IOCTL_UNLINK failed");
+ if (ioctl(fd, SNDRV_PCM_IOCTL_UNLINK) < 0) {
+ SYSERR("SNDRV_PCM_IOCTL_UNLINK failed");
return -errno;
}
return 0;
int shmid;
} snd_pcm_hw_t;
-#define SND_FILE_PCM_STREAM_PLAYBACK "/dev/snd/pcmC%iD%ip"
-#define SND_FILE_PCM_STREAM_CAPTURE "/dev/snd/pcmC%iD%ic"
-#define SND_PCM_VERSION_MAX SND_PROTOCOL_VERSION(2, 0, 0)
+#define SNDRV_FILE_PCM_STREAM_PLAYBACK "/dev/snd/pcmC%iD%ip"
+#define SNDRV_FILE_PCM_STREAM_CAPTURE "/dev/snd/pcmC%iD%ic"
+#define SNDRV_PCM_VERSION_MAX SNDRV_PROTOCOL_VERSION(2, 0, 0)
static int snd_pcm_hw_nonblock(snd_pcm_t *pcm, int nonblock)
{
{
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
- if (ioctl(fd, SND_PCM_IOCTL_INFO, info) < 0) {
- SYSERR("SND_PCM_IOCTL_INFO failed");
+ if (ioctl(fd, SNDRV_PCM_IOCTL_INFO, info) < 0) {
+ SYSERR("SNDRV_PCM_IOCTL_INFO failed");
return -errno;
}
return 0;
{
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
- if (ioctl(fd, SND_PCM_IOCTL_HW_REFINE, params) < 0) {
- // SYSERR("SND_PCM_IOCTL_HW_REFINE failed");
+ if (ioctl(fd, SNDRV_PCM_IOCTL_HW_REFINE, params) < 0) {
+ // SYSERR("SNDRV_PCM_IOCTL_HW_REFINE failed");
return -errno;
}
return 0;
{
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
- if (ioctl(fd, SND_PCM_IOCTL_HW_PARAMS, params) < 0) {
- SYSERR("SND_PCM_IOCTL_HW_PARAMS failed");
+ if (ioctl(fd, SNDRV_PCM_IOCTL_HW_PARAMS, params) < 0) {
+ SYSERR("SNDRV_PCM_IOCTL_HW_PARAMS failed");
return -errno;
}
return 0;
{
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
- if (ioctl(fd, SND_PCM_IOCTL_HW_FREE) < 0) {
- SYSERR("SND_PCM_IOCTL_HW_FREE failed");
+ if (ioctl(fd, SNDRV_PCM_IOCTL_HW_FREE) < 0) {
+ SYSERR("SNDRV_PCM_IOCTL_HW_FREE failed");
return -errno;
}
return 0;
hw->mmap_control->avail_min = params->avail_min;
return 0;
}
- if (ioctl(fd, SND_PCM_IOCTL_SW_PARAMS, params) < 0) {
- SYSERR("SND_PCM_IOCTL_SW_PARAMS failed");
+ if (ioctl(fd, SNDRV_PCM_IOCTL_SW_PARAMS, params) < 0) {
+ SYSERR("SNDRV_PCM_IOCTL_SW_PARAMS failed");
return -errno;
}
return 0;
snd_pcm_hw_channel_info_t hw_info;
int fd = hw->fd;
hw_info.channel = info->channel;
- if (ioctl(fd, SND_PCM_IOCTL_CHANNEL_INFO, &hw_info) < 0) {
- SYSERR("SND_PCM_IOCTL_CHANNEL_INFO failed");
+ if (ioctl(fd, SNDRV_PCM_IOCTL_CHANNEL_INFO, &hw_info) < 0) {
+ SYSERR("SNDRV_PCM_IOCTL_CHANNEL_INFO failed");
return -errno;
}
info->channel = hw_info.channel;
{
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
- if (ioctl(fd, SND_PCM_IOCTL_STATUS, status) < 0) {
- SYSERR("SND_PCM_IOCTL_STATUS failed");
+ if (ioctl(fd, SNDRV_PCM_IOCTL_STATUS, status) < 0) {
+ SYSERR("SNDRV_PCM_IOCTL_STATUS failed");
return -errno;
}
return 0;
{
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
- if (ioctl(fd, SND_PCM_IOCTL_DELAY, delayp) < 0) {
- SYSERR("SND_PCM_IOCTL_DELAY failed");
+ if (ioctl(fd, SNDRV_PCM_IOCTL_DELAY, delayp) < 0) {
+ SYSERR("SNDRV_PCM_IOCTL_DELAY failed");
return -errno;
}
return 0;
{
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
- if (ioctl(fd, SND_PCM_IOCTL_PREPARE) < 0) {
- SYSERR("SND_PCM_IOCTL_PREPARE failed");
+ if (ioctl(fd, SNDRV_PCM_IOCTL_PREPARE) < 0) {
+ SYSERR("SNDRV_PCM_IOCTL_PREPARE failed");
return -errno;
}
return 0;
{
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
- if (ioctl(fd, SND_PCM_IOCTL_RESET) < 0) {
- SYSERR("SND_PCM_IOCTL_RESET failed");
+ if (ioctl(fd, SNDRV_PCM_IOCTL_RESET) < 0) {
+ SYSERR("SNDRV_PCM_IOCTL_RESET failed");
return -errno;
}
return 0;
assert(pcm->stream != SND_PCM_STREAM_PLAYBACK ||
snd_pcm_mmap_playback_hw_avail(pcm) > 0);
#endif
- if (ioctl(fd, SND_PCM_IOCTL_START) < 0) {
- SYSERR("SND_PCM_IOCTL_START failed");
+ if (ioctl(fd, SNDRV_PCM_IOCTL_START) < 0) {
+ SYSERR("SNDRV_PCM_IOCTL_START failed");
return -errno;
}
return 0;
{
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
- if (ioctl(fd, SND_PCM_IOCTL_DROP) < 0) {
- SYSERR("SND_PCM_IOCTL_DROP failed");
+ if (ioctl(fd, SNDRV_PCM_IOCTL_DROP) < 0) {
+ SYSERR("SNDRV_PCM_IOCTL_DROP failed");
return -errno;
}
return 0;
{
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
- if (ioctl(fd, SND_PCM_IOCTL_DRAIN) < 0) {
- SYSERR("SND_PCM_IOCTL_DRAIN failed");
+ if (ioctl(fd, SNDRV_PCM_IOCTL_DRAIN) < 0) {
+ SYSERR("SNDRV_PCM_IOCTL_DRAIN failed");
return -errno;
}
return 0;
{
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
- if (ioctl(fd, SND_PCM_IOCTL_PAUSE, enable) < 0) {
- SYSERR("SND_PCM_IOCTL_PAUSE failed");
+ if (ioctl(fd, SNDRV_PCM_IOCTL_PAUSE, enable) < 0) {
+ SYSERR("SNDRV_PCM_IOCTL_PAUSE failed");
return -errno;
}
return 0;
{
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
- if (ioctl(fd, SND_PCM_IOCTL_REWIND, &frames) < 0) {
- SYSERR("SND_PCM_IOCTL_REWIND failed");
+ if (ioctl(fd, SNDRV_PCM_IOCTL_REWIND, &frames) < 0) {
+ SYSERR("SNDRV_PCM_IOCTL_REWIND failed");
return -errno;
}
return 0;
snd_xferi_t xferi;
xferi.buf = (char*) buffer;
xferi.frames = size;
- result = ioctl(fd, SND_PCM_IOCTL_WRITEI_FRAMES, &xferi);
+ result = ioctl(fd, SNDRV_PCM_IOCTL_WRITEI_FRAMES, &xferi);
if (result < 0)
return -errno;
return xferi.result;
snd_xfern_t xfern;
xfern.bufs = bufs;
xfern.frames = size;
- result = ioctl(fd, SND_PCM_IOCTL_WRITEN_FRAMES, &xfern);
+ result = ioctl(fd, SNDRV_PCM_IOCTL_WRITEN_FRAMES, &xfern);
if (result < 0)
return -errno;
return xfern.result;
snd_xferi_t xferi;
xferi.buf = buffer;
xferi.frames = size;
- result = ioctl(fd, SND_PCM_IOCTL_READI_FRAMES, &xferi);
+ result = ioctl(fd, SNDRV_PCM_IOCTL_READI_FRAMES, &xferi);
if (result < 0)
return -errno;
return xferi.result;
snd_xfern_t xfern;
xfern.bufs = bufs;
xfern.frames = size;
- result = ioctl(fd, SND_PCM_IOCTL_READN_FRAMES, &xfern);
+ result = ioctl(fd, SNDRV_PCM_IOCTL_READN_FRAMES, &xfern);
if (result < 0)
return -errno;
return xfern.result;
switch (stream) {
case SND_PCM_STREAM_PLAYBACK:
- filefmt = SND_FILE_PCM_STREAM_PLAYBACK;
+ filefmt = SNDRV_FILE_PCM_STREAM_PLAYBACK;
break;
case SND_PCM_STREAM_CAPTURE:
- filefmt = SND_FILE_PCM_STREAM_CAPTURE;
+ filefmt = SNDRV_FILE_PCM_STREAM_CAPTURE;
break;
default:
assert(0);
ret = -errno;
goto _err;
}
- if (ioctl(fd, SND_PCM_IOCTL_PVERSION, &ver) < 0) {
- SYSERR("SND_PCM_IOCTL_PVERSION failed");
+ if (ioctl(fd, SNDRV_PCM_IOCTL_PVERSION, &ver) < 0) {
+ SYSERR("SNDRV_PCM_IOCTL_PVERSION failed");
ret = -errno;
goto _err;
}
- if (SND_PROTOCOL_INCOMPATIBLE(ver, SND_PCM_VERSION_MAX)) {
+ if (SNDRV_PROTOCOL_INCOMPATIBLE(ver, SNDRV_PCM_VERSION_MAX)) {
ret = -SND_ERROR_INCOMPATIBLE_VERSION;
goto _err;
}
if (subdevice >= 0) {
memset(&info, 0, sizeof(info));
- if (ioctl(fd, SND_PCM_IOCTL_INFO, &info) < 0) {
- SYSERR("SND_PCM_IOCTL_INFO failed");
+ if (ioctl(fd, SNDRV_PCM_IOCTL_INFO, &info) < 0) {
+ SYSERR("SNDRV_PCM_IOCTL_INFO failed");
ret = -errno;
goto _err;
}
int snd_pcm_format_signed(int format)
{
switch (format) {
- case SND_PCM_FORMAT_S8:
- case SND_PCM_FORMAT_S16_LE:
- case SND_PCM_FORMAT_S16_BE:
- case SND_PCM_FORMAT_S24_LE:
- case SND_PCM_FORMAT_S24_BE:
- case SND_PCM_FORMAT_S32_LE:
- case SND_PCM_FORMAT_S32_BE:
+ case SNDRV_PCM_FORMAT_S8:
+ case SNDRV_PCM_FORMAT_S16_LE:
+ case SNDRV_PCM_FORMAT_S16_BE:
+ case SNDRV_PCM_FORMAT_S24_LE:
+ case SNDRV_PCM_FORMAT_S24_BE:
+ case SNDRV_PCM_FORMAT_S32_LE:
+ case SNDRV_PCM_FORMAT_S32_BE:
return 1;
- case SND_PCM_FORMAT_U8:
- case SND_PCM_FORMAT_U16_LE:
- case SND_PCM_FORMAT_U16_BE:
- case SND_PCM_FORMAT_U24_LE:
- case SND_PCM_FORMAT_U24_BE:
- case SND_PCM_FORMAT_U32_LE:
- case SND_PCM_FORMAT_U32_BE:
+ case SNDRV_PCM_FORMAT_U8:
+ case SNDRV_PCM_FORMAT_U16_LE:
+ case SNDRV_PCM_FORMAT_U16_BE:
+ case SNDRV_PCM_FORMAT_U24_LE:
+ case SNDRV_PCM_FORMAT_U24_BE:
+ case SNDRV_PCM_FORMAT_U32_LE:
+ case SNDRV_PCM_FORMAT_U32_BE:
return 0;
default:
return -EINVAL;
int snd_pcm_format_little_endian(int format)
{
switch (format) {
- case SND_PCM_FORMAT_S16_LE:
- case SND_PCM_FORMAT_U16_LE:
- case SND_PCM_FORMAT_S24_LE:
- case SND_PCM_FORMAT_U24_LE:
- case SND_PCM_FORMAT_S32_LE:
- case SND_PCM_FORMAT_U32_LE:
- case SND_PCM_FORMAT_FLOAT_LE:
- case SND_PCM_FORMAT_FLOAT64_LE:
- case SND_PCM_FORMAT_IEC958_SUBFRAME_LE:
+ case SNDRV_PCM_FORMAT_S16_LE:
+ case SNDRV_PCM_FORMAT_U16_LE:
+ case SNDRV_PCM_FORMAT_S24_LE:
+ case SNDRV_PCM_FORMAT_U24_LE:
+ case SNDRV_PCM_FORMAT_S32_LE:
+ case SNDRV_PCM_FORMAT_U32_LE:
+ case SNDRV_PCM_FORMAT_FLOAT_LE:
+ case SNDRV_PCM_FORMAT_FLOAT64_LE:
+ case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE:
return 1;
- case SND_PCM_FORMAT_S16_BE:
- case SND_PCM_FORMAT_U16_BE:
- case SND_PCM_FORMAT_S24_BE:
- case SND_PCM_FORMAT_U24_BE:
- case SND_PCM_FORMAT_S32_BE:
- case SND_PCM_FORMAT_U32_BE:
- case SND_PCM_FORMAT_FLOAT_BE:
- case SND_PCM_FORMAT_FLOAT64_BE:
- case SND_PCM_FORMAT_IEC958_SUBFRAME_BE:
+ case SNDRV_PCM_FORMAT_S16_BE:
+ case SNDRV_PCM_FORMAT_U16_BE:
+ case SNDRV_PCM_FORMAT_S24_BE:
+ case SNDRV_PCM_FORMAT_U24_BE:
+ case SNDRV_PCM_FORMAT_S32_BE:
+ case SNDRV_PCM_FORMAT_U32_BE:
+ case SNDRV_PCM_FORMAT_FLOAT_BE:
+ case SNDRV_PCM_FORMAT_FLOAT64_BE:
+ case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE:
return 0;
default:
return -EINVAL;
int snd_pcm_format_cpu_endian(int format)
{
-#ifdef SND_LITTLE_ENDIAN
+#ifdef SNDRV_LITTLE_ENDIAN
return snd_pcm_format_little_endian(format);
#else
return snd_pcm_format_big_endian(format);
int snd_pcm_format_width(int format)
{
switch (format) {
- case SND_PCM_FORMAT_S8:
- case SND_PCM_FORMAT_U8:
+ case SNDRV_PCM_FORMAT_S8:
+ case SNDRV_PCM_FORMAT_U8:
return 8;
- case SND_PCM_FORMAT_S16_LE:
- case SND_PCM_FORMAT_S16_BE:
- case SND_PCM_FORMAT_U16_LE:
- case SND_PCM_FORMAT_U16_BE:
+ case SNDRV_PCM_FORMAT_S16_LE:
+ case SNDRV_PCM_FORMAT_S16_BE:
+ case SNDRV_PCM_FORMAT_U16_LE:
+ case SNDRV_PCM_FORMAT_U16_BE:
return 16;
- case SND_PCM_FORMAT_S24_LE:
- case SND_PCM_FORMAT_S24_BE:
- case SND_PCM_FORMAT_U24_LE:
- case SND_PCM_FORMAT_U24_BE:
+ case SNDRV_PCM_FORMAT_S24_LE:
+ case SNDRV_PCM_FORMAT_S24_BE:
+ case SNDRV_PCM_FORMAT_U24_LE:
+ case SNDRV_PCM_FORMAT_U24_BE:
return 24;
- case SND_PCM_FORMAT_S32_LE:
- case SND_PCM_FORMAT_S32_BE:
- case SND_PCM_FORMAT_U32_LE:
- case SND_PCM_FORMAT_U32_BE:
- case SND_PCM_FORMAT_FLOAT_LE:
- case SND_PCM_FORMAT_FLOAT_BE:
+ case SNDRV_PCM_FORMAT_S32_LE:
+ case SNDRV_PCM_FORMAT_S32_BE:
+ case SNDRV_PCM_FORMAT_U32_LE:
+ case SNDRV_PCM_FORMAT_U32_BE:
+ case SNDRV_PCM_FORMAT_FLOAT_LE:
+ case SNDRV_PCM_FORMAT_FLOAT_BE:
return 32;
- case SND_PCM_FORMAT_FLOAT64_LE:
- case SND_PCM_FORMAT_FLOAT64_BE:
+ case SNDRV_PCM_FORMAT_FLOAT64_LE:
+ case SNDRV_PCM_FORMAT_FLOAT64_BE:
return 64;
- case SND_PCM_FORMAT_IEC958_SUBFRAME_LE:
- case SND_PCM_FORMAT_IEC958_SUBFRAME_BE:
+ case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE:
+ case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE:
return 24;
- case SND_PCM_FORMAT_MU_LAW:
- case SND_PCM_FORMAT_A_LAW:
+ case SNDRV_PCM_FORMAT_MU_LAW:
+ case SNDRV_PCM_FORMAT_A_LAW:
return 8;
- case SND_PCM_FORMAT_IMA_ADPCM:
+ case SNDRV_PCM_FORMAT_IMA_ADPCM:
return 4;
default:
return -EINVAL;
int snd_pcm_format_physical_width(int format)
{
switch (format) {
- case SND_PCM_FORMAT_S8:
- case SND_PCM_FORMAT_U8:
+ case SNDRV_PCM_FORMAT_S8:
+ case SNDRV_PCM_FORMAT_U8:
return 8;
- case SND_PCM_FORMAT_S16_LE:
- case SND_PCM_FORMAT_S16_BE:
- case SND_PCM_FORMAT_U16_LE:
- case SND_PCM_FORMAT_U16_BE:
+ case SNDRV_PCM_FORMAT_S16_LE:
+ case SNDRV_PCM_FORMAT_S16_BE:
+ case SNDRV_PCM_FORMAT_U16_LE:
+ case SNDRV_PCM_FORMAT_U16_BE:
return 16;
- case SND_PCM_FORMAT_S24_LE:
- case SND_PCM_FORMAT_S24_BE:
- case SND_PCM_FORMAT_U24_LE:
- case SND_PCM_FORMAT_U24_BE:
- case SND_PCM_FORMAT_S32_LE:
- case SND_PCM_FORMAT_S32_BE:
- case SND_PCM_FORMAT_U32_LE:
- case SND_PCM_FORMAT_U32_BE:
- case SND_PCM_FORMAT_FLOAT_LE:
- case SND_PCM_FORMAT_FLOAT_BE:
- case SND_PCM_FORMAT_IEC958_SUBFRAME_LE:
- case SND_PCM_FORMAT_IEC958_SUBFRAME_BE:
+ case SNDRV_PCM_FORMAT_S24_LE:
+ case SNDRV_PCM_FORMAT_S24_BE:
+ case SNDRV_PCM_FORMAT_U24_LE:
+ case SNDRV_PCM_FORMAT_U24_BE:
+ case SNDRV_PCM_FORMAT_S32_LE:
+ case SNDRV_PCM_FORMAT_S32_BE:
+ case SNDRV_PCM_FORMAT_U32_LE:
+ case SNDRV_PCM_FORMAT_U32_BE:
+ case SNDRV_PCM_FORMAT_FLOAT_LE:
+ case SNDRV_PCM_FORMAT_FLOAT_BE:
+ case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE:
+ case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE:
return 32;
- case SND_PCM_FORMAT_FLOAT64_LE:
- case SND_PCM_FORMAT_FLOAT64_BE:
+ case SNDRV_PCM_FORMAT_FLOAT64_LE:
+ case SNDRV_PCM_FORMAT_FLOAT64_BE:
return 64;
- case SND_PCM_FORMAT_MU_LAW:
- case SND_PCM_FORMAT_A_LAW:
+ case SNDRV_PCM_FORMAT_MU_LAW:
+ case SNDRV_PCM_FORMAT_A_LAW:
return 8;
- case SND_PCM_FORMAT_IMA_ADPCM:
+ case SNDRV_PCM_FORMAT_IMA_ADPCM:
return 4;
default:
return -EINVAL;
ssize_t snd_pcm_format_size(int format, size_t samples)
{
switch (format) {
- case SND_PCM_FORMAT_S8:
- case SND_PCM_FORMAT_U8:
+ case SNDRV_PCM_FORMAT_S8:
+ case SNDRV_PCM_FORMAT_U8:
return samples;
- case SND_PCM_FORMAT_S16_LE:
- case SND_PCM_FORMAT_S16_BE:
- case SND_PCM_FORMAT_U16_LE:
- case SND_PCM_FORMAT_U16_BE:
+ case SNDRV_PCM_FORMAT_S16_LE:
+ case SNDRV_PCM_FORMAT_S16_BE:
+ case SNDRV_PCM_FORMAT_U16_LE:
+ case SNDRV_PCM_FORMAT_U16_BE:
return samples * 2;
- case SND_PCM_FORMAT_S24_LE:
- case SND_PCM_FORMAT_S24_BE:
- case SND_PCM_FORMAT_U24_LE:
- case SND_PCM_FORMAT_U24_BE:
- case SND_PCM_FORMAT_S32_LE:
- case SND_PCM_FORMAT_S32_BE:
- case SND_PCM_FORMAT_U32_LE:
- case SND_PCM_FORMAT_U32_BE:
- case SND_PCM_FORMAT_FLOAT_LE:
- case SND_PCM_FORMAT_FLOAT_BE:
+ case SNDRV_PCM_FORMAT_S24_LE:
+ case SNDRV_PCM_FORMAT_S24_BE:
+ case SNDRV_PCM_FORMAT_U24_LE:
+ case SNDRV_PCM_FORMAT_U24_BE:
+ case SNDRV_PCM_FORMAT_S32_LE:
+ case SNDRV_PCM_FORMAT_S32_BE:
+ case SNDRV_PCM_FORMAT_U32_LE:
+ case SNDRV_PCM_FORMAT_U32_BE:
+ case SNDRV_PCM_FORMAT_FLOAT_LE:
+ case SNDRV_PCM_FORMAT_FLOAT_BE:
return samples * 4;
- case SND_PCM_FORMAT_FLOAT64_LE:
- case SND_PCM_FORMAT_FLOAT64_BE:
+ case SNDRV_PCM_FORMAT_FLOAT64_LE:
+ case SNDRV_PCM_FORMAT_FLOAT64_BE:
return samples * 8;
- case SND_PCM_FORMAT_IEC958_SUBFRAME_LE:
- case SND_PCM_FORMAT_IEC958_SUBFRAME_BE:
+ case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE:
+ case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE:
return samples * 4;
- case SND_PCM_FORMAT_MU_LAW:
- case SND_PCM_FORMAT_A_LAW:
+ case SNDRV_PCM_FORMAT_MU_LAW:
+ case SNDRV_PCM_FORMAT_A_LAW:
return samples;
- case SND_PCM_FORMAT_IMA_ADPCM:
+ case SNDRV_PCM_FORMAT_IMA_ADPCM:
if (samples & 1)
return -EINVAL;
return samples / 2;
u_int64_t snd_pcm_format_silence_64(int format)
{
switch (format) {
- case SND_PCM_FORMAT_S8:
- case SND_PCM_FORMAT_S16_LE:
- case SND_PCM_FORMAT_S16_BE:
- case SND_PCM_FORMAT_S24_LE:
- case SND_PCM_FORMAT_S24_BE:
- case SND_PCM_FORMAT_S32_LE:
- case SND_PCM_FORMAT_S32_BE:
+ case SNDRV_PCM_FORMAT_S8:
+ case SNDRV_PCM_FORMAT_S16_LE:
+ case SNDRV_PCM_FORMAT_S16_BE:
+ case SNDRV_PCM_FORMAT_S24_LE:
+ case SNDRV_PCM_FORMAT_S24_BE:
+ case SNDRV_PCM_FORMAT_S32_LE:
+ case SNDRV_PCM_FORMAT_S32_BE:
return 0;
- case SND_PCM_FORMAT_U8:
+ case SNDRV_PCM_FORMAT_U8:
return 0x8080808080808080ULL;
-#ifdef SND_LITTLE_ENDIAN
- case SND_PCM_FORMAT_U16_LE:
+#ifdef SNDRV_LITTLE_ENDIAN
+ case SNDRV_PCM_FORMAT_U16_LE:
return 0x8000800080008000ULL;
- case SND_PCM_FORMAT_U24_LE:
+ case SNDRV_PCM_FORMAT_U24_LE:
return 0x0080000000800000ULL;
- case SND_PCM_FORMAT_U32_LE:
+ case SNDRV_PCM_FORMAT_U32_LE:
return 0x8000000080000000ULL;
- case SND_PCM_FORMAT_U16_BE:
+ case SNDRV_PCM_FORMAT_U16_BE:
return 0x0080008000800080ULL;
- case SND_PCM_FORMAT_U24_BE:
+ case SNDRV_PCM_FORMAT_U24_BE:
return 0x0000800000008000ULL;
- case SND_PCM_FORMAT_U32_BE:
+ case SNDRV_PCM_FORMAT_U32_BE:
return 0x0000008000000080ULL;
#else
- case SND_PCM_FORMAT_U16_LE:
+ case SNDRV_PCM_FORMAT_U16_LE:
return 0x0080008000800080ULL;
- case SND_PCM_FORMAT_U24_LE:
+ case SNDRV_PCM_FORMAT_U24_LE:
return 0x0000800000008000ULL;
- case SND_PCM_FORMAT_U32_LE:
+ case SNDRV_PCM_FORMAT_U32_LE:
return 0x0000008000000080ULL;
- case SND_PCM_FORMAT_U16_BE:
+ case SNDRV_PCM_FORMAT_U16_BE:
return 0x8000800080008000ULL;
- case SND_PCM_FORMAT_U24_BE:
+ case SNDRV_PCM_FORMAT_U24_BE:
return 0x0080000000800000ULL;
- case SND_PCM_FORMAT_U32_BE:
+ case SNDRV_PCM_FORMAT_U32_BE:
return 0x8000000080000000ULL;
#endif
- case SND_PCM_FORMAT_FLOAT_LE:
+ case SNDRV_PCM_FORMAT_FLOAT_LE:
{
union {
float f;
u_int32_t i;
} u;
u.f = 0.0;
-#ifdef SND_LITTLE_ENDIAN
+#ifdef SNDRV_LITTLE_ENDIAN
return u.i;
#else
return bswap_32(u.i);
#endif
}
- case SND_PCM_FORMAT_FLOAT64_LE:
+ case SNDRV_PCM_FORMAT_FLOAT64_LE:
{
union {
double f;
u_int64_t i;
} u;
u.f = 0.0;
-#ifdef SND_LITTLE_ENDIAN
+#ifdef SNDRV_LITTLE_ENDIAN
return u.i;
#else
return bswap_64(u.i);
#endif
}
- case SND_PCM_FORMAT_FLOAT_BE:
+ case SNDRV_PCM_FORMAT_FLOAT_BE:
{
union {
float f;
u_int32_t i;
} u;
u.f = 0.0;
-#ifdef SND_LITTLE_ENDIAN
+#ifdef SNDRV_LITTLE_ENDIAN
return bswap_32(u.i);
#else
return u.i;
#endif
}
- case SND_PCM_FORMAT_FLOAT64_BE:
+ case SNDRV_PCM_FORMAT_FLOAT64_BE:
{
union {
double f;
u_int64_t i;
} u;
u.f = 0.0;
-#ifdef SND_LITTLE_ENDIAN
+#ifdef SNDRV_LITTLE_ENDIAN
return bswap_64(u.i);
#else
return u.i;
#endif
}
- case SND_PCM_FORMAT_IEC958_SUBFRAME_LE:
- case SND_PCM_FORMAT_IEC958_SUBFRAME_BE:
+ case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE:
+ case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE:
return 0;
- case SND_PCM_FORMAT_MU_LAW:
+ case SNDRV_PCM_FORMAT_MU_LAW:
return 0x7f7f7f7f7f7f7f7fULL;
- case SND_PCM_FORMAT_A_LAW:
+ case SNDRV_PCM_FORMAT_A_LAW:
return 0x5555555555555555ULL;
- case SND_PCM_FORMAT_IMA_ADPCM: /* special case */
- case SND_PCM_FORMAT_MPEG:
- case SND_PCM_FORMAT_GSM:
+ case SNDRV_PCM_FORMAT_IMA_ADPCM: /* special case */
+ case SNDRV_PCM_FORMAT_MPEG:
+ case SNDRV_PCM_FORMAT_GSM:
return 0;
}
return 0;
}
static int linear_formats[4*2*2] = {
- SND_PCM_FORMAT_S8,
- SND_PCM_FORMAT_S8,
- SND_PCM_FORMAT_U8,
- SND_PCM_FORMAT_U8,
- SND_PCM_FORMAT_S16_LE,
- SND_PCM_FORMAT_S16_BE,
- SND_PCM_FORMAT_U16_LE,
- SND_PCM_FORMAT_U16_BE,
- SND_PCM_FORMAT_S24_LE,
- SND_PCM_FORMAT_S24_BE,
- SND_PCM_FORMAT_U24_LE,
- SND_PCM_FORMAT_U24_BE,
- SND_PCM_FORMAT_S32_LE,
- SND_PCM_FORMAT_S32_BE,
- SND_PCM_FORMAT_U32_LE,
- SND_PCM_FORMAT_U32_BE
+ SNDRV_PCM_FORMAT_S8,
+ SNDRV_PCM_FORMAT_S8,
+ SNDRV_PCM_FORMAT_U8,
+ SNDRV_PCM_FORMAT_U8,
+ SNDRV_PCM_FORMAT_S16_LE,
+ SNDRV_PCM_FORMAT_S16_BE,
+ SNDRV_PCM_FORMAT_U16_LE,
+ SNDRV_PCM_FORMAT_U16_BE,
+ SNDRV_PCM_FORMAT_S24_LE,
+ SNDRV_PCM_FORMAT_S24_BE,
+ SNDRV_PCM_FORMAT_U24_LE,
+ SNDRV_PCM_FORMAT_U24_BE,
+ SNDRV_PCM_FORMAT_S32_LE,
+ SNDRV_PCM_FORMAT_S32_BE,
+ SNDRV_PCM_FORMAT_U32_LE,
+ SNDRV_PCM_FORMAT_U32_BE
};
int snd_pcm_build_linear_format(int width, int unsignd, int big_endian)
volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl;
int err;
// ctrl->u.info = *info;
- ctrl->cmd = SND_PCM_IOCTL_INFO;
+ ctrl->cmd = SNDRV_PCM_IOCTL_INFO;
err = snd_pcm_shm_action(pcm);
if (err < 0)
return err;
volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl;
int err;
ctrl->u.hw_refine = *params;
- ctrl->cmd = SND_PCM_IOCTL_HW_REFINE;
+ ctrl->cmd = SNDRV_PCM_IOCTL_HW_REFINE;
err = snd_pcm_shm_action(pcm);
*params = ctrl->u.hw_refine;
return err;
snd_pcm_shm_t *shm = pcm->private;
volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl;
int err;
- ctrl->cmd = SND_PCM_IOCTL_HW_PARAMS;
+ ctrl->cmd = SNDRV_PCM_IOCTL_HW_PARAMS;
ctrl->u.hw_params = *params;
err = snd_pcm_shm_action(pcm);
*params = ctrl->u.hw_params;
{
snd_pcm_shm_t *shm = pcm->private;
volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl;
- ctrl->cmd = SND_PCM_IOCTL_HW_FREE;
+ ctrl->cmd = SNDRV_PCM_IOCTL_HW_FREE;
return snd_pcm_shm_action(pcm);
}
snd_pcm_shm_t *shm = pcm->private;
volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl;
int err;
- ctrl->cmd = SND_PCM_IOCTL_SW_PARAMS;
+ ctrl->cmd = SNDRV_PCM_IOCTL_SW_PARAMS;
ctrl->u.sw_params = *params;
err = snd_pcm_shm_action(pcm);
*params = ctrl->u.sw_params;
volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl;
int err;
int fd;
- ctrl->cmd = SND_PCM_IOCTL_CHANNEL_INFO;
+ ctrl->cmd = SNDRV_PCM_IOCTL_CHANNEL_INFO;
ctrl->u.channel_info = *info;
err = snd_pcm_shm_action_fd(pcm, &fd);
if (err < 0)
snd_pcm_shm_t *shm = pcm->private;
volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl;
int err;
- ctrl->cmd = SND_PCM_IOCTL_STATUS;
+ ctrl->cmd = SNDRV_PCM_IOCTL_STATUS;
// ctrl->u.status = *status;
err = snd_pcm_shm_action(pcm);
if (err < 0)
snd_pcm_shm_t *shm = pcm->private;
volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl;
int err;
- ctrl->cmd = SND_PCM_IOCTL_DELAY;
+ ctrl->cmd = SNDRV_PCM_IOCTL_DELAY;
err = snd_pcm_shm_action(pcm);
if (err < 0)
return err;
{
snd_pcm_shm_t *shm = pcm->private;
volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl;
- ctrl->cmd = SND_PCM_IOCTL_PREPARE;
+ ctrl->cmd = SNDRV_PCM_IOCTL_PREPARE;
return snd_pcm_shm_action(pcm);
}
{
snd_pcm_shm_t *shm = pcm->private;
volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl;
- ctrl->cmd = SND_PCM_IOCTL_RESET;
+ ctrl->cmd = SNDRV_PCM_IOCTL_RESET;
return snd_pcm_shm_action(pcm);
}
{
snd_pcm_shm_t *shm = pcm->private;
volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl;
- ctrl->cmd = SND_PCM_IOCTL_START;
+ ctrl->cmd = SNDRV_PCM_IOCTL_START;
return snd_pcm_shm_action(pcm);
}
{
snd_pcm_shm_t *shm = pcm->private;
volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl;
- ctrl->cmd = SND_PCM_IOCTL_DROP;
+ ctrl->cmd = SNDRV_PCM_IOCTL_DROP;
return snd_pcm_shm_action(pcm);
}
snd_pcm_shm_t *shm = pcm->private;
volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl;
int err;
- ctrl->cmd = SND_PCM_IOCTL_DRAIN;
+ ctrl->cmd = SNDRV_PCM_IOCTL_DRAIN;
err = snd_pcm_shm_action(pcm);
if (err < 0)
return err;
{
snd_pcm_shm_t *shm = pcm->private;
volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl;
- ctrl->cmd = SND_PCM_IOCTL_PAUSE;
+ ctrl->cmd = SNDRV_PCM_IOCTL_PAUSE;
ctrl->u.pause.enable = enable;
return snd_pcm_shm_action(pcm);
}
{
snd_pcm_shm_t *shm = pcm->private;
volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl;
- ctrl->cmd = SND_PCM_IOCTL_REWIND;
+ ctrl->cmd = SNDRV_PCM_IOCTL_REWIND;
ctrl->u.rewind.frames = frames;
return snd_pcm_shm_action(pcm);
}
#include "rawmidi_local.h"
#include "asoundlib.h"
-#define SND_FILE_RAWMIDI "/dev/snd/midiC%iD%i"
-#define SND_RAWMIDI_VERSION_MAX SND_PROTOCOL_VERSION(2, 0, 0)
+#define SNDRV_FILE_RAWMIDI "/dev/snd/midiC%iD%i"
+#define SNDRV_RAWMIDI_VERSION_MAX SNDRV_PROTOCOL_VERSION(2, 0, 0)
typedef struct {
int fd;
static int snd_rawmidi_hw_info(snd_rawmidi_t *rmidi, snd_rawmidi_info_t * info)
{
snd_rawmidi_hw_t *hw = rmidi->private;
- if (ioctl(hw->fd, SND_RAWMIDI_IOCTL_INFO, info) < 0) {
- SYSERR("SND_RAWMIDI_IOCTL_INFO failed");
+ if (ioctl(hw->fd, SNDRV_RAWMIDI_IOCTL_INFO, info) < 0) {
+ SYSERR("SNDRV_RAWMIDI_IOCTL_INFO failed");
return -errno;
}
return 0;
static int snd_rawmidi_hw_params(snd_rawmidi_t *rmidi, snd_rawmidi_params_t * params)
{
snd_rawmidi_hw_t *hw = rmidi->private;
- if (ioctl(hw->fd, SND_RAWMIDI_IOCTL_PARAMS, params) < 0) {
- SYSERR("SND_RAWMIDI_IOCTL_PARAMS failed");
+ if (ioctl(hw->fd, SNDRV_RAWMIDI_IOCTL_PARAMS, params) < 0) {
+ SYSERR("SNDRV_RAWMIDI_IOCTL_PARAMS failed");
return -errno;
}
return 0;
static int snd_rawmidi_hw_status(snd_rawmidi_t *rmidi, snd_rawmidi_status_t * status)
{
snd_rawmidi_hw_t *hw = rmidi->private;
- if (ioctl(hw->fd, SND_RAWMIDI_IOCTL_STATUS, status) < 0) {
- SYSERR("SND_RAWMIDI_IOCTL_STATUS failed");
+ if (ioctl(hw->fd, SNDRV_RAWMIDI_IOCTL_STATUS, status) < 0) {
+ SYSERR("SNDRV_RAWMIDI_IOCTL_STATUS failed");
return -errno;
}
return 0;
static int snd_rawmidi_hw_drop(snd_rawmidi_t *rmidi, int stream)
{
snd_rawmidi_hw_t *hw = rmidi->private;
- if (ioctl(hw->fd, SND_RAWMIDI_IOCTL_DROP, &stream) < 0) {
- SYSERR("SND_RAWMIDI_IOCTL_DROP failed");
+ if (ioctl(hw->fd, SNDRV_RAWMIDI_IOCTL_DROP, &stream) < 0) {
+ SYSERR("SNDRV_RAWMIDI_IOCTL_DROP failed");
return -errno;
}
return 0;
static int snd_rawmidi_hw_drain(snd_rawmidi_t *rmidi, int stream)
{
snd_rawmidi_hw_t *hw = rmidi->private;
- if (ioctl(hw->fd, SND_RAWMIDI_IOCTL_DRAIN, &stream) < 0) {
- SYSERR("SND_RAWMIDI_IOCTL_DRAIN failed");
+ if (ioctl(hw->fd, SNDRV_RAWMIDI_IOCTL_DRAIN, &stream) < 0) {
+ SYSERR("SNDRV_RAWMIDI_IOCTL_DRAIN failed");
return -errno;
}
return 0;
if ((ret = snd_ctl_hw_open(&ctl, NULL, card)) < 0)
return ret;
- sprintf(filename, SND_FILE_RAWMIDI, card, device);
+ sprintf(filename, SNDRV_FILE_RAWMIDI, card, device);
__again:
if (attempt++ > 3) {
return -errno;
}
}
- if (ioctl(fd, SND_RAWMIDI_IOCTL_PVERSION, &ver) < 0) {
+ if (ioctl(fd, SNDRV_RAWMIDI_IOCTL_PVERSION, &ver) < 0) {
ret = -errno;
- SYSERR("SND_RAWMIDI_IOCTL_PVERSION failed");
+ SYSERR("SNDRV_RAWMIDI_IOCTL_PVERSION failed");
close(fd);
snd_ctl_close(ctl);
return ret;
}
- if (SND_PROTOCOL_INCOMPATIBLE(ver, SND_RAWMIDI_VERSION_MAX)) {
+ if (SNDRV_PROTOCOL_INCOMPATIBLE(ver, SNDRV_RAWMIDI_VERSION_MAX)) {
close(fd);
snd_ctl_close(ctl);
return -SND_ERROR_INCOMPATIBLE_VERSION;
}
if (subdevice >= 0) {
memset(&info, 0, sizeof(info));
- if (ioctl(fd, SND_RAWMIDI_IOCTL_INFO, &info) < 0) {
- SYSERR("SND_RAWMIDI_IOCTL_INFO failed");
+ if (ioctl(fd, SNDRV_RAWMIDI_IOCTL_INFO, &info) < 0) {
+ SYSERR("SNDRV_RAWMIDI_IOCTL_INFO failed");
ret = -errno;
close(fd);
snd_ctl_close(ctl);
#include "seq_local.h"
#include "asoundlib.h"
-#define SND_FILE_SEQ "/dev/snd/seq"
-#define SND_FILE_ALOADSEQ "/dev/aloadSEQ"
-#define SND_SEQ_VERSION_MAX SND_PROTOCOL_VERSION(1, 0, 0)
+#define SNDRV_FILE_SEQ "/dev/snd/seq"
+#define SNDRV_FILE_ALOADSEQ "/dev/aloadSEQ"
+#define SNDRV_SEQ_VERSION_MAX SNDRV_PROTOCOL_VERSION(1, 0, 0)
typedef struct {
int fd;
{
snd_seq_hw_t *hw = seq->private;
int client;
- if (ioctl(hw->fd, SND_SEQ_IOCTL_CLIENT_ID, &client) < 0) {
- SYSERR("SND_SEQ_IOCTL_CLIENT_ID failed");
+ if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_CLIENT_ID, &client) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_CLIENT_ID failed");
return -errno;
}
return client;
static int snd_seq_hw_system_info(snd_seq_t *seq, snd_seq_system_info_t * info)
{
snd_seq_hw_t *hw = seq->private;
- if (ioctl(hw->fd, SND_SEQ_IOCTL_SYSTEM_INFO, info) < 0) {
- SYSERR("SND_SEQ_IOCTL_SYSTEM_INFO failed");
+ if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_SYSTEM_INFO, info) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_SYSTEM_INFO failed");
return -errno;
}
return 0;
static int snd_seq_hw_get_client_info(snd_seq_t *seq, snd_seq_client_info_t * info)
{
snd_seq_hw_t *hw = seq->private;
- if (ioctl(hw->fd, SND_SEQ_IOCTL_GET_CLIENT_INFO, info) < 0) {
- SYSERR("SND_SEQ_IOCTL_GET_CLIENT_INFO failed");
+ if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_GET_CLIENT_INFO, info) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_GET_CLIENT_INFO failed");
return -errno;
}
return 0;
static int snd_seq_hw_set_client_info(snd_seq_t *seq, snd_seq_client_info_t * info)
{
snd_seq_hw_t *hw = seq->private;
- if (ioctl(hw->fd, SND_SEQ_IOCTL_SET_CLIENT_INFO, info) < 0) {
- SYSERR("SND_SEQ_IOCTL_SET_CLIENT_INFO failed");
+ if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_SET_CLIENT_INFO, info) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_SET_CLIENT_INFO failed");
return -errno;
}
return 0;
static int snd_seq_hw_create_port(snd_seq_t *seq, snd_seq_port_info_t * port)
{
snd_seq_hw_t *hw = seq->private;
- if (ioctl(hw->fd, SND_SEQ_IOCTL_CREATE_PORT, port) < 0) {
- SYSERR("SND_SEQ_IOCTL_CREATE_PORT failed");
+ if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_CREATE_PORT, port) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_CREATE_PORT failed");
return -errno;
}
return 0;
static int snd_seq_hw_delete_port(snd_seq_t *seq, snd_seq_port_info_t * port)
{
snd_seq_hw_t *hw = seq->private;
- if (ioctl(hw->fd, SND_SEQ_IOCTL_DELETE_PORT, port) < 0) {
- SYSERR("SND_SEQ_IOCTL_DELETE_PORT failed");
+ if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_DELETE_PORT, port) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_DELETE_PORT failed");
return -errno;
}
return 0;
static int snd_seq_hw_get_port_info(snd_seq_t *seq, snd_seq_port_info_t * info)
{
snd_seq_hw_t *hw = seq->private;
- if (ioctl(hw->fd, SND_SEQ_IOCTL_GET_PORT_INFO, info) < 0) {
- SYSERR("SND_SEQ_IOCTL_GET_PORT_INFO failed");
+ if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_GET_PORT_INFO, info) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_GET_PORT_INFO failed");
return -errno;
}
return 0;
static int snd_seq_hw_set_port_info(snd_seq_t *seq, snd_seq_port_info_t * info)
{
snd_seq_hw_t *hw = seq->private;
- if (ioctl(hw->fd, SND_SEQ_IOCTL_SET_PORT_INFO, info) < 0) {
- SYSERR("SND_SEQ_IOCTL_SET_PORT_INFO failed");
+ if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_SET_PORT_INFO, info) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_SET_PORT_INFO failed");
return -errno;
}
return 0;
static int snd_seq_hw_get_port_subscription(snd_seq_t *seq, snd_seq_port_subscribe_t * sub)
{
snd_seq_hw_t *hw = seq->private;
- if (ioctl(hw->fd, SND_SEQ_IOCTL_GET_SUBSCRIPTION, sub) < 0) {
- SYSERR("SND_SEQ_IOCTL_GET_SUBSCRIPTION failed");
+ if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_GET_SUBSCRIPTION, sub) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_GET_SUBSCRIPTION failed");
return -errno;
}
return 0;
static int snd_seq_hw_subscribe_port(snd_seq_t *seq, snd_seq_port_subscribe_t * sub)
{
snd_seq_hw_t *hw = seq->private;
- if (ioctl(hw->fd, SND_SEQ_IOCTL_SUBSCRIBE_PORT, sub) < 0) {
- SYSERR("SND_SEQ_IOCTL_SUBSCRIBE_PORT failed");
+ if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT, sub) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT failed");
return -errno;
}
return 0;
static int snd_seq_hw_unsubscribe_port(snd_seq_t *seq, snd_seq_port_subscribe_t * sub)
{
snd_seq_hw_t *hw = seq->private;
- if (ioctl(hw->fd, SND_SEQ_IOCTL_UNSUBSCRIBE_PORT, sub) < 0) {
- SYSERR("SND_SEQ_IOCTL_UNSUBSCRIBE_PORT failed");
+ if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_UNSUBSCRIBE_PORT, sub) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_UNSUBSCRIBE_PORT failed");
return -errno;
}
return 0;
static int snd_seq_hw_query_port_subscribers(snd_seq_t *seq, snd_seq_query_subs_t * subs)
{
snd_seq_hw_t *hw = seq->private;
- if (ioctl(hw->fd, SND_SEQ_IOCTL_QUERY_SUBS, subs) < 0) {
- SYSERR("SND_SEQ_IOCTL_QUERY_SUBS failed");
+ if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_QUERY_SUBS, subs) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_QUERY_SUBS failed");
return -errno;
}
return 0;
static int snd_seq_hw_get_queue_status(snd_seq_t *seq, snd_seq_queue_status_t * status)
{
snd_seq_hw_t *hw = seq->private;
- if (ioctl(hw->fd, SND_SEQ_IOCTL_GET_QUEUE_STATUS, status) < 0) {
- SYSERR("SND_SEQ_IOCTL_GET_QUEUE_STATUS failed");
+ if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_GET_QUEUE_STATUS, status) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_GET_QUEUE_STATUS failed");
return -errno;
}
return 0;
static int snd_seq_hw_get_queue_tempo(snd_seq_t *seq, snd_seq_queue_tempo_t * tempo)
{
snd_seq_hw_t *hw = seq->private;
- if (ioctl(hw->fd, SND_SEQ_IOCTL_GET_QUEUE_TEMPO, tempo) < 0) {
- SYSERR("SND_SEQ_IOCTL_GET_QUEUE_TEMPO failed");
+ if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_GET_QUEUE_TEMPO, tempo) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_GET_QUEUE_TEMPO failed");
return -errno;
}
return 0;
static int snd_seq_hw_set_queue_tempo(snd_seq_t *seq, snd_seq_queue_tempo_t * tempo)
{
snd_seq_hw_t *hw = seq->private;
- if (ioctl(hw->fd, SND_SEQ_IOCTL_SET_QUEUE_TEMPO, tempo) < 0) {
- SYSERR("SND_SEQ_IOCTL_SET_QUEUE_TEMPO failed");
+ if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_SET_QUEUE_TEMPO, tempo) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_SET_QUEUE_TEMPO failed");
return -errno;
}
return 0;
static int snd_seq_hw_get_queue_owner(snd_seq_t *seq, snd_seq_queue_owner_t * owner)
{
snd_seq_hw_t *hw = seq->private;
- if (ioctl(hw->fd, SND_SEQ_IOCTL_GET_QUEUE_OWNER, owner) < 0) {
- SYSERR("SND_SEQ_IOCTL_GET_QUEUE_OWNER failed");
+ if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_GET_QUEUE_OWNER, owner) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_GET_QUEUE_OWNER failed");
return -errno;
}
return 0;
static int snd_seq_hw_set_queue_owner(snd_seq_t *seq, snd_seq_queue_owner_t * owner)
{
snd_seq_hw_t *hw = seq->private;
- if (ioctl(hw->fd, SND_SEQ_IOCTL_SET_QUEUE_OWNER, owner) < 0) {
- SYSERR("SND_SEQ_IOCTL_SET_QUEUE_OWNER failed");
+ if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_SET_QUEUE_OWNER, owner) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_SET_QUEUE_OWNER failed");
return -errno;
}
return 0;
static int snd_seq_hw_get_queue_timer(snd_seq_t *seq, snd_seq_queue_timer_t * timer)
{
snd_seq_hw_t *hw = seq->private;
- if (ioctl(hw->fd, SND_SEQ_IOCTL_GET_QUEUE_TIMER, timer) < 0) {
- SYSERR("SND_SEQ_IOCTL_GET_QUEUE_TIMER failed");
+ if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_GET_QUEUE_TIMER, timer) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_GET_QUEUE_TIMER failed");
return -errno;
}
return 0;
static int snd_seq_hw_set_queue_timer(snd_seq_t *seq, snd_seq_queue_timer_t * timer)
{
snd_seq_hw_t *hw = seq->private;
- if (ioctl(hw->fd, SND_SEQ_IOCTL_SET_QUEUE_TIMER, timer) < 0) {
- SYSERR("SND_SEQ_IOCTL_SET_QUEUE_TIMER failed");
+ if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_SET_QUEUE_TIMER, timer) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_SET_QUEUE_TIMER failed");
return -errno;
}
return 0;
static int snd_seq_hw_get_queue_client(snd_seq_t *seq, snd_seq_queue_client_t * info)
{
snd_seq_hw_t *hw = seq->private;
- if (ioctl(hw->fd, SND_SEQ_IOCTL_GET_QUEUE_CLIENT, info) < 0) {
- SYSERR("SND_SEQ_IOCTL_GET_QUEUE_CLIENT failed");
+ if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_GET_QUEUE_CLIENT, info) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_GET_QUEUE_CLIENT failed");
return -errno;
}
return 0;
static int snd_seq_hw_set_queue_client(snd_seq_t *seq, snd_seq_queue_client_t * info)
{
snd_seq_hw_t *hw = seq->private;
- if (ioctl(hw->fd, SND_SEQ_IOCTL_SET_QUEUE_CLIENT, info) < 0) {
- SYSERR("SND_SEQ_IOCTL_SET_QUEUE_CLIENT failed");
+ if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_SET_QUEUE_CLIENT, info) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_SET_QUEUE_CLIENT failed");
return -errno;
}
return 0;
static int snd_seq_hw_create_queue(snd_seq_t *seq, snd_seq_queue_info_t *info)
{
snd_seq_hw_t *hw = seq->private;
- if (ioctl(hw->fd, SND_SEQ_IOCTL_CREATE_QUEUE, info) < 0) {
- SYSERR("SND_SEQ_IOCTL_CREATE_QUEUE failed");
+ if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_CREATE_QUEUE, info) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_CREATE_QUEUE failed");
return -errno;
}
return 0;
static int snd_seq_hw_delete_queue(snd_seq_t *seq, snd_seq_queue_info_t *info)
{
snd_seq_hw_t *hw = seq->private;
- if (ioctl(hw->fd, SND_SEQ_IOCTL_DELETE_QUEUE, info) < 0) {
- SYSERR("SND_SEQ_IOCTL_DELETE_QUEUE failed");
+ if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_DELETE_QUEUE, info) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_DELETE_QUEUE failed");
return -errno;
}
return 0;
static int snd_seq_hw_get_queue_info(snd_seq_t *seq, snd_seq_queue_info_t *info)
{
snd_seq_hw_t *hw = seq->private;
- if (ioctl(hw->fd, SND_SEQ_IOCTL_GET_QUEUE_INFO, info) < 0) {
- SYSERR("SND_SEQ_IOCTL_GET_QUEUE_INFO failed");
+ if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_GET_QUEUE_INFO, info) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_GET_QUEUE_INFO failed");
return -errno;
}
return 0;
static int snd_seq_hw_set_queue_info(snd_seq_t *seq, snd_seq_queue_info_t *info)
{
snd_seq_hw_t *hw = seq->private;
- if (ioctl(hw->fd, SND_SEQ_IOCTL_SET_QUEUE_INFO, info) < 0) {
- SYSERR("SND_SEQ_IOCTL_SET_QUEUE_INFO failed");
+ if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_SET_QUEUE_INFO, info) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_SET_QUEUE_INFO failed");
return -errno;
}
return 0;
static int snd_seq_hw_get_named_queue(snd_seq_t *seq, snd_seq_queue_info_t *info)
{
snd_seq_hw_t *hw = seq->private;
- if (ioctl(hw->fd, SND_SEQ_IOCTL_GET_NAMED_QUEUE, info) < 0) {
- SYSERR("SND_SEQ_IOCTL_GET_NAMED_QUEUE failed");
+ if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_GET_NAMED_QUEUE, info) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_GET_NAMED_QUEUE failed");
return -errno;
}
return 0;
static int snd_seq_hw_remove_events(snd_seq_t *seq, snd_seq_remove_events_t *rmp)
{
snd_seq_hw_t *hw = seq->private;
- if (ioctl(hw->fd, SND_SEQ_IOCTL_REMOVE_EVENTS, rmp) < 0) {
- SYSERR("SND_SEQ_IOCTL_REMOVE_EVENTS failed");
+ if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_REMOVE_EVENTS, rmp) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_REMOVE_EVENTS failed");
return -errno;
}
return 0;
static int snd_seq_hw_get_client_pool(snd_seq_t *seq, snd_seq_client_pool_t *info)
{
snd_seq_hw_t *hw = seq->private;
- if (ioctl(hw->fd, SND_SEQ_IOCTL_GET_CLIENT_POOL, info) < 0) {
- SYSERR("SND_SEQ_IOCTL_GET_CLIENT_POOL failed");
+ if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_GET_CLIENT_POOL, info) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_GET_CLIENT_POOL failed");
return -errno;
}
return 0;
static int snd_seq_hw_set_client_pool(snd_seq_t *seq, snd_seq_client_pool_t *info)
{
snd_seq_hw_t *hw = seq->private;
- if (ioctl(hw->fd, SND_SEQ_IOCTL_SET_CLIENT_POOL, info) < 0) {
- SYSERR("SND_SEQ_IOCTL_SET_CLIENT_POOL failed");
+ if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_SET_CLIENT_POOL, info) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_SET_CLIENT_POOL failed");
return -errno;
}
return 0;
static int snd_seq_hw_query_next_client(snd_seq_t *seq, snd_seq_client_info_t *info)
{
snd_seq_hw_t *hw = seq->private;
- if (ioctl(hw->fd, SND_SEQ_IOCTL_QUERY_NEXT_CLIENT, info) < 0) {
- SYSERR("SND_SEQ_IOCTL_QUERY_NEXT_CLIENT failed");
+ if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_QUERY_NEXT_CLIENT, info) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_QUERY_NEXT_CLIENT failed");
return -errno;
}
return 0;
static int snd_seq_hw_query_next_port(snd_seq_t *seq, snd_seq_port_info_t *info)
{
snd_seq_hw_t *hw = seq->private;
- if (ioctl(hw->fd, SND_SEQ_IOCTL_QUERY_NEXT_PORT, info) < 0) {
- SYSERR("SND_SEQ_IOCTL_QUERY_NEXT_PORT failed");
+ if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_QUERY_NEXT_PORT, info) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_QUERY_NEXT_PORT failed");
return -errno;
}
return 0;
if (mode & SND_SEQ_NONBLOCK)
fmode |= O_NONBLOCK;
- sprintf(filename, SND_FILE_SEQ);
+ sprintf(filename, SNDRV_FILE_SEQ);
if ((fd = open(filename, fmode)) < 0) {
- close(open(SND_FILE_ALOADSEQ, O_RDWR));
+ close(open(SNDRV_FILE_ALOADSEQ, O_RDWR));
if ((fd = open(filename, fmode)) < 0) {
SYSERR("open %s failed", filename);
return -errno;
}
}
- if (ioctl(fd, SND_SEQ_IOCTL_PVERSION, &ver) < 0) {
- SYSERR("SND_SEQ_IOCTL_PVERSION failed");
+ if (ioctl(fd, SNDRV_SEQ_IOCTL_PVERSION, &ver) < 0) {
+ SYSERR("SNDRV_SEQ_IOCTL_PVERSION failed");
close(fd);
return -errno;
}
- if (SND_PROTOCOL_INCOMPATIBLE(ver, SND_SEQ_VERSION_MAX)) {
+ if (SNDRV_PROTOCOL_INCOMPATIBLE(ver, SNDRV_SEQ_VERSION_MAX)) {
close(fd);
return -SND_ERROR_INCOMPATIBLE_VERSION;
}
c &= 0xff;
- if (c >= SND_MCMD_COMMON_CLOCK) {
+ if (c >= MIDI_CMD_COMMON_CLOCK) {
/* real-time event */
ev->type = status_event[ST_SPECIAL + c - 0xf0].event;
ev->flags &= ~SND_SEQ_EVENT_LENGTH_MASK;
status_event[dev->type].encode(dev, ev);
rc = 1;
} else if (dev->type == ST_SYSEX) {
- if (c == SND_MCMD_COMMON_SYSEX_END ||
+ if (c == MIDI_CMD_COMMON_SYSEX_END ||
dev->read >= dev->bufsize) {
ev->flags &= ~SND_SEQ_EVENT_LENGTH_MASK;
ev->flags |= SND_SEQ_EVENT_LENGTH_VARIABLE;
ev->data.ext.len = dev->read;
ev->data.ext.ptr = dev->buf;
- if (c != SND_MCMD_COMMON_SYSEX_END)
+ if (c != MIDI_CMD_COMMON_SYSEX_END)
dev->read = 0; /* continue to parse */
else
reset_encode(dev); /* all parsed */
cmd = 0x80 | (type << 4) | (ev->data.note.channel & 0x0f);
- if (cmd == SND_MCMD_COMMON_SYSEX) {
+ if (cmd == MIDI_CMD_COMMON_SYSEX) {
qlen = ev->data.ext.len;
if (count < qlen)
return -ENOMEM;
if (ev->data.control.param < 32) {
if (count < 5)
return -ENOMEM;
- buf[0] = SND_MCMD_CONTROL|(ev->data.control.channel & 0x0f);
+ buf[0] = MIDI_CMD_CONTROL|(ev->data.control.channel & 0x0f);
buf[1] = ev->data.control.param;
buf[2] = (ev->data.control.value >> 7) & 0x7f;
buf[3] = ev->data.control.param + 32;
} else {
if (count < 3)
return -ENOMEM;
- buf[0] = SND_MCMD_CONTROL|(ev->data.control.channel & 0x0f);
+ buf[0] = MIDI_CMD_CONTROL|(ev->data.control.channel & 0x0f);
buf[1] = ev->data.control.param & 0x7f;
buf[4] = ev->data.control.value & 0x7f;
dev->lastcmd = buf[0];
#include <sys/ioctl.h>
#include "asoundlib.h"
-#define SND_FILE_TIMER "/dev/snd/timer"
-#define SND_TIMER_VERSION_MAX SND_PROTOCOL_VERSION(2, 0, 0)
+#define SNDRV_FILE_TIMER "/dev/snd/timer"
+#define SNDRV_TIMER_VERSION_MAX SNDRV_PROTOCOL_VERSION(2, 0, 0)
struct _snd_timer {
int fd;
*handle = NULL;
- if ((fd = open(SND_FILE_TIMER, O_RDONLY)) < 0)
+ if ((fd = open(SNDRV_FILE_TIMER, O_RDONLY)) < 0)
return -errno;
- if (ioctl(fd, SND_TIMER_IOCTL_PVERSION, &ver) < 0) {
+ if (ioctl(fd, SNDRV_TIMER_IOCTL_PVERSION, &ver) < 0) {
close(fd);
return -errno;
}
- if (SND_PROTOCOL_INCOMPATIBLE(ver, SND_TIMER_VERSION_MAX)) {
+ if (SNDRV_PROTOCOL_INCOMPATIBLE(ver, SNDRV_TIMER_VERSION_MAX)) {
close(fd);
return -SND_ERROR_INCOMPATIBLE_VERSION;
}
tmr = handle;
if (!tmr || !tid)
return -EINVAL;
- if (ioctl(tmr->fd, SND_TIMER_IOCTL_NEXT_DEVICE, tid) < 0)
+ if (ioctl(tmr->fd, SNDRV_TIMER_IOCTL_NEXT_DEVICE, tid) < 0)
return -errno;
return 0;
}
tmr = handle;
if (!tmr || !tselect)
return -EINVAL;
- if (ioctl(tmr->fd, SND_TIMER_IOCTL_SELECT, tselect) < 0)
+ if (ioctl(tmr->fd, SNDRV_TIMER_IOCTL_SELECT, tselect) < 0)
return -errno;
return 0;
}
tmr = handle;
if (!tmr || !info)
return -EINVAL;
- if (ioctl(tmr->fd, SND_TIMER_IOCTL_INFO, info) < 0)
+ if (ioctl(tmr->fd, SNDRV_TIMER_IOCTL_INFO, info) < 0)
return -errno;
return 0;
}
tmr = handle;
if (!tmr || !params)
return -EINVAL;
- if (ioctl(tmr->fd, SND_TIMER_IOCTL_PARAMS, params) < 0)
+ if (ioctl(tmr->fd, SNDRV_TIMER_IOCTL_PARAMS, params) < 0)
return -errno;
return 0;
}
tmr = handle;
if (!tmr || !status)
return -EINVAL;
- if (ioctl(tmr->fd, SND_TIMER_IOCTL_STATUS, status) < 0)
+ if (ioctl(tmr->fd, SNDRV_TIMER_IOCTL_STATUS, status) < 0)
return -errno;
return 0;
}
tmr = handle;
if (!tmr)
return -EINVAL;
- if (ioctl(tmr->fd, SND_TIMER_IOCTL_START) < 0)
+ if (ioctl(tmr->fd, SNDRV_TIMER_IOCTL_START) < 0)
return -errno;
return 0;
}
tmr = handle;
if (!tmr)
return -EINVAL;
- if (ioctl(tmr->fd, SND_TIMER_IOCTL_STOP) < 0)
+ if (ioctl(tmr->fd, SNDRV_TIMER_IOCTL_STOP) < 0)
return -errno;
return 0;
}
tmr = handle;
if (!tmr)
return -EINVAL;
- if (ioctl(tmr->fd, SND_TIMER_IOCTL_CONTINUE) < 0)
+ if (ioctl(tmr->fd, SNDRV_TIMER_IOCTL_CONTINUE) < 0)
return -errno;
return 0;
}
git://git.alsa-project.org / alsa-lib.git / commitdiff