From: Abramo Bagnara Date: Mon, 29 Jan 2001 14:27:53 +0000 (+0000) Subject: First step toward encapsulation X-Git-Tag: v1.0.3~1002 X-Git-Url: https://git.alsa-project.org/?a=commitdiff_plain;h=70809b1835746ab3bfb0af81f41be0b8d699d65d;p=alsa-lib.git First step toward encapsulation --- diff --git a/aserver/aserver.c b/aserver/aserver.c index 8dc55550..5cdc3d79 100644 --- a/aserver/aserver.c +++ b/aserver/aserver.c @@ -379,75 +379,75 @@ int pcm_shm_cmd(client_t *client) 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: @@ -577,10 +577,10 @@ int ctl_shm_cmd(client_t *client) 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) { @@ -591,37 +591,37 @@ int ctl_shm_cmd(client_t *client) 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: diff --git a/include/header.h b/include/header.h index 51648a95..343c9692 100644 --- a/include/header.h +++ b/include/header.h @@ -24,6 +24,7 @@ #define __ASOUNDLIB_H #include +#include #include #include #include @@ -36,3 +37,608 @@ #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 diff --git a/src/control/control_hw.c b/src/control/control_hw.c index 85f80653..394e5e9a 100644 --- a/src/control/control_hw.c +++ b/src/control/control_hw.c @@ -31,8 +31,8 @@ #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; @@ -63,7 +63,7 @@ static int snd_ctl_hw_poll_descriptor(snd_ctl_t *handle) 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; } @@ -71,7 +71,7 @@ static int snd_ctl_hw_hw_info(snd_ctl_t *handle, snd_ctl_hw_info_t *info) 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; } @@ -79,7 +79,7 @@ static int snd_ctl_hw_clist(snd_ctl_t *handle, snd_control_list_t *list) 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; } @@ -87,7 +87,7 @@ static int snd_ctl_hw_cinfo(snd_ctl_t *handle, snd_control_info_t *info) 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; } @@ -95,7 +95,7 @@ static int snd_ctl_hw_cread(snd_ctl_t *handle, snd_control_t *control) 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; } @@ -103,7 +103,7 @@ static int snd_ctl_hw_cwrite(snd_ctl_t *handle, snd_control_t *control) 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; } @@ -111,7 +111,7 @@ static int snd_ctl_hw_hwdep_next_device(snd_ctl_t *handle, int * device) 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; } @@ -119,7 +119,7 @@ static int snd_ctl_hw_hwdep_info(snd_ctl_t *handle, snd_hwdep_info_t * info) 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; } @@ -127,7 +127,7 @@ static int snd_ctl_hw_pcm_next_device(snd_ctl_t *handle, int * device) 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; } @@ -135,7 +135,7 @@ static int snd_ctl_hw_pcm_info(snd_ctl_t *handle, snd_pcm_info_t * info) 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; } @@ -143,7 +143,7 @@ static int snd_ctl_hw_pcm_prefer_subdevice(snd_ctl_t *handle, int subdev) 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; } @@ -151,7 +151,7 @@ static int snd_ctl_hw_rawmidi_next_device(snd_ctl_t *handle, int * device) 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; } @@ -159,7 +159,7 @@ static int snd_ctl_hw_rawmidi_info(snd_ctl_t *handle, snd_rawmidi_info_t * info) 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; } @@ -200,18 +200,18 @@ int snd_ctl_hw_open(snd_ctl_t **handle, char *name, int card) *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; } diff --git a/src/control/control_shm.c b/src/control/control_shm.c index d61ad8eb..673e14d3 100644 --- a/src/control/control_shm.c +++ b/src/control/control_shm.c @@ -121,7 +121,7 @@ static int snd_ctl_shm_hw_info(snd_ctl_t *ctl, snd_ctl_hw_info_t *info) 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; @@ -140,7 +140,7 @@ static int snd_ctl_shm_clist(snd_ctl_t *ctl, snd_control_list_t *list) 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; @@ -156,7 +156,7 @@ static int snd_ctl_shm_cinfo(snd_ctl_t *ctl, snd_control_info_t *info) 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; @@ -170,7 +170,7 @@ static int snd_ctl_shm_cread(snd_ctl_t *ctl, snd_control_t *control) 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; @@ -184,7 +184,7 @@ static int snd_ctl_shm_cwrite(snd_ctl_t *ctl, snd_control_t *control) 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; @@ -198,7 +198,7 @@ static int snd_ctl_shm_hwdep_next_device(snd_ctl_t *ctl, int * device) 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; @@ -212,7 +212,7 @@ static int snd_ctl_shm_hwdep_info(snd_ctl_t *ctl, snd_hwdep_info_t * info) 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; @@ -226,7 +226,7 @@ static int snd_ctl_shm_pcm_next_device(snd_ctl_t *ctl, int * device) 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; @@ -240,7 +240,7 @@ static int snd_ctl_shm_pcm_info(snd_ctl_t *ctl, snd_pcm_info_t * info) 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; @@ -254,7 +254,7 @@ static int snd_ctl_shm_pcm_prefer_subdevice(snd_ctl_t *ctl, int subdev) 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; @@ -267,7 +267,7 @@ static int snd_ctl_shm_rawmidi_next_device(snd_ctl_t *ctl, int * device) 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; @@ -281,7 +281,7 @@ static int snd_ctl_shm_rawmidi_info(snd_ctl_t *ctl, snd_rawmidi_info_t * info) 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; @@ -295,7 +295,7 @@ static int snd_ctl_shm_rawmidi_prefer_subdevice(snd_ctl_t *ctl, int subdev) 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; diff --git a/src/hwdep/hwdep.c b/src/hwdep/hwdep.c index aa35765a..4829c59c 100644 --- a/src/hwdep/hwdep.c +++ b/src/hwdep/hwdep.c @@ -28,8 +28,8 @@ #include #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; @@ -48,17 +48,17 @@ int snd_hwdep_open(snd_hwdep_t **handle, int card, int device, int mode) 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; } @@ -114,7 +114,7 @@ int snd_hwdep_info(snd_hwdep_t *hwdep, snd_hwdep_info_t * info) { 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; } diff --git a/src/pcm/pcm.c b/src/pcm/pcm.c index f10bcb22..d188e9b7 100644 --- a/src/pcm/pcm.c +++ b/src/pcm/pcm.c @@ -244,8 +244,8 @@ int snd_pcm_link(snd_pcm_t *pcm1, snd_pcm_t *pcm2) 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; @@ -262,8 +262,8 @@ int snd_pcm_unlink(snd_pcm_t *pcm) 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; diff --git a/src/pcm/pcm_hw.c b/src/pcm/pcm_hw.c index 55b5c85b..2f12353f 100644 --- a/src/pcm/pcm_hw.c +++ b/src/pcm/pcm_hw.c @@ -49,9 +49,9 @@ typedef struct { 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) { @@ -119,8 +119,8 @@ static int snd_pcm_hw_info(snd_pcm_t *pcm, snd_pcm_info_t * info) { 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; @@ -130,8 +130,8 @@ static int snd_pcm_hw_hw_refine(snd_pcm_t *pcm, snd_pcm_hw_params_t *params) { 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; @@ -141,8 +141,8 @@ static int snd_pcm_hw_hw_params(snd_pcm_t *pcm, snd_pcm_hw_params_t * params) { 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; @@ -152,8 +152,8 @@ static int snd_pcm_hw_hw_free(snd_pcm_t *pcm) { 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; @@ -174,8 +174,8 @@ static int snd_pcm_hw_sw_params(snd_pcm_t *pcm, snd_pcm_sw_params_t * params) 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; @@ -187,8 +187,8 @@ static int snd_pcm_hw_channel_info(snd_pcm_t *pcm, snd_pcm_channel_info_t * info 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; @@ -208,8 +208,8 @@ static int snd_pcm_hw_status(snd_pcm_t *pcm, snd_pcm_status_t * status) { 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; @@ -225,8 +225,8 @@ static int snd_pcm_hw_delay(snd_pcm_t *pcm, snd_pcm_sframes_t *delayp) { 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; @@ -236,8 +236,8 @@ static int snd_pcm_hw_prepare(snd_pcm_t *pcm) { 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; @@ -247,8 +247,8 @@ static int snd_pcm_hw_reset(snd_pcm_t *pcm) { 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; @@ -262,8 +262,8 @@ static int snd_pcm_hw_start(snd_pcm_t *pcm) 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; @@ -273,8 +273,8 @@ static int snd_pcm_hw_drop(snd_pcm_t *pcm) { 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; @@ -284,8 +284,8 @@ static int snd_pcm_hw_drain(snd_pcm_t *pcm) { 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; @@ -295,8 +295,8 @@ static int snd_pcm_hw_pause(snd_pcm_t *pcm, int enable) { 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; @@ -306,8 +306,8 @@ static snd_pcm_sframes_t snd_pcm_hw_rewind(snd_pcm_t *pcm, snd_pcm_uframes_t fra { 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; @@ -321,7 +321,7 @@ static snd_pcm_sframes_t snd_pcm_hw_writei(snd_pcm_t *pcm, const void *buffer, s 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; @@ -335,7 +335,7 @@ static snd_pcm_sframes_t snd_pcm_hw_writen(snd_pcm_t *pcm, void **bufs, snd_pcm_ 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; @@ -349,7 +349,7 @@ static snd_pcm_sframes_t snd_pcm_hw_readi(snd_pcm_t *pcm, void *buffer, snd_pcm_ 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; @@ -363,7 +363,7 @@ snd_pcm_sframes_t snd_pcm_hw_readn(snd_pcm_t *pcm, void **bufs, snd_pcm_uframes_ 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; @@ -568,10 +568,10 @@ int snd_pcm_hw_open_subdevice(snd_pcm_t **pcmp, int card, int device, int subdev 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); @@ -596,19 +596,19 @@ int snd_pcm_hw_open_subdevice(snd_pcm_t **pcmp, int card, int device, int subdev 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; } diff --git a/src/pcm/pcm_misc.c b/src/pcm/pcm_misc.c index fa7b7e7b..7a0b6131 100644 --- a/src/pcm/pcm_misc.c +++ b/src/pcm/pcm_misc.c @@ -39,21 +39,21 @@ 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; @@ -78,25 +78,25 @@ int snd_pcm_format_linear(int format) 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; @@ -115,7 +115,7 @@ int snd_pcm_format_big_endian(int format) 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); @@ -125,36 +125,36 @@ int snd_pcm_format_cpu_endian(int 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; @@ -164,34 +164,34 @@ int snd_pcm_format_width(int format) 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; @@ -201,35 +201,35 @@ int snd_pcm_format_physical_width(int format) 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; @@ -241,105 +241,105 @@ ssize_t snd_pcm_format_size(int format, size_t samples) 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; @@ -404,22 +404,22 @@ int snd_pcm_format_set_silence(int format, void *data, unsigned int samples) } 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) diff --git a/src/pcm/pcm_shm.c b/src/pcm/pcm_shm.c index b478ec7c..3e21df3b 100644 --- a/src/pcm/pcm_shm.c +++ b/src/pcm/pcm_shm.c @@ -147,7 +147,7 @@ static int snd_pcm_shm_info(snd_pcm_t *pcm, snd_pcm_info_t * info) 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; @@ -215,7 +215,7 @@ static int snd_pcm_shm_hw_refine_slave(snd_pcm_t *pcm, 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; @@ -237,7 +237,7 @@ static int snd_pcm_shm_hw_params_slave(snd_pcm_t *pcm, 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; @@ -257,7 +257,7 @@ static int snd_pcm_shm_hw_free(snd_pcm_t *pcm) { 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); } @@ -266,7 +266,7 @@ static int snd_pcm_shm_sw_params(snd_pcm_t *pcm, snd_pcm_sw_params_t * params) 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; @@ -314,7 +314,7 @@ static int snd_pcm_shm_channel_info(snd_pcm_t *pcm, snd_pcm_channel_info_t * inf 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) @@ -339,7 +339,7 @@ static int snd_pcm_shm_status(snd_pcm_t *pcm, snd_pcm_status_t * status) 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) @@ -361,7 +361,7 @@ static int snd_pcm_shm_delay(snd_pcm_t *pcm, snd_pcm_sframes_t *delayp) 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; @@ -385,7 +385,7 @@ static int snd_pcm_shm_prepare(snd_pcm_t *pcm) { 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); } @@ -393,7 +393,7 @@ static int snd_pcm_shm_reset(snd_pcm_t *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); } @@ -401,7 +401,7 @@ static int snd_pcm_shm_start(snd_pcm_t *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); } @@ -409,7 +409,7 @@ static int snd_pcm_shm_drop(snd_pcm_t *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); } @@ -418,7 +418,7 @@ static int snd_pcm_shm_drain(snd_pcm_t *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; @@ -431,7 +431,7 @@ static int snd_pcm_shm_pause(snd_pcm_t *pcm, int enable) { 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); } @@ -440,7 +440,7 @@ static snd_pcm_sframes_t snd_pcm_shm_rewind(snd_pcm_t *pcm, snd_pcm_uframes_t fr { 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); } diff --git a/src/rawmidi/rawmidi_hw.c b/src/rawmidi/rawmidi_hw.c index c11432ac..e9d7fcee 100644 --- a/src/rawmidi/rawmidi_hw.c +++ b/src/rawmidi/rawmidi_hw.c @@ -31,8 +31,8 @@ #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; @@ -79,8 +79,8 @@ static int snd_rawmidi_hw_nonblock(snd_rawmidi_t *rmidi, int nonblock) 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; @@ -89,8 +89,8 @@ static int snd_rawmidi_hw_info(snd_rawmidi_t *rmidi, snd_rawmidi_info_t * info) 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; @@ -99,8 +99,8 @@ static int snd_rawmidi_hw_params(snd_rawmidi_t *rmidi, snd_rawmidi_params_t * pa 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; @@ -109,8 +109,8 @@ static int snd_rawmidi_hw_status(snd_rawmidi_t *rmidi, snd_rawmidi_status_t * st 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; @@ -119,8 +119,8 @@ static int snd_rawmidi_hw_drop(snd_rawmidi_t *rmidi, int stream) 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; @@ -177,7 +177,7 @@ int snd_rawmidi_hw_open(snd_rawmidi_t **handlep, char *name, int card, int devic 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) { @@ -224,22 +224,22 @@ int snd_rawmidi_hw_open(snd_rawmidi_t **handlep, char *name, int card, int devic 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); diff --git a/src/seq/seq_hw.c b/src/seq/seq_hw.c index 4f7e243c..436a2d41 100644 --- a/src/seq/seq_hw.c +++ b/src/seq/seq_hw.c @@ -25,9 +25,9 @@ #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; @@ -68,8 +68,8 @@ static int snd_seq_hw_client_id(snd_seq_t *seq) { 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; @@ -78,8 +78,8 @@ static int snd_seq_hw_client_id(snd_seq_t *seq) 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; @@ -88,8 +88,8 @@ static int snd_seq_hw_system_info(snd_seq_t *seq, snd_seq_system_info_t * info) 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; @@ -98,8 +98,8 @@ static int snd_seq_hw_get_client_info(snd_seq_t *seq, snd_seq_client_info_t * in 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; @@ -108,8 +108,8 @@ static int snd_seq_hw_set_client_info(snd_seq_t *seq, snd_seq_client_info_t * in 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; @@ -118,8 +118,8 @@ static int snd_seq_hw_create_port(snd_seq_t *seq, snd_seq_port_info_t * port) 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; @@ -128,8 +128,8 @@ static int snd_seq_hw_delete_port(snd_seq_t *seq, snd_seq_port_info_t * port) 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; @@ -138,8 +138,8 @@ static int snd_seq_hw_get_port_info(snd_seq_t *seq, snd_seq_port_info_t * info) 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; @@ -148,8 +148,8 @@ static int snd_seq_hw_set_port_info(snd_seq_t *seq, snd_seq_port_info_t * info) 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; @@ -158,8 +158,8 @@ static int snd_seq_hw_get_port_subscription(snd_seq_t *seq, snd_seq_port_subscri 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; @@ -168,8 +168,8 @@ static int snd_seq_hw_subscribe_port(snd_seq_t *seq, snd_seq_port_subscribe_t * 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; @@ -178,8 +178,8 @@ static int snd_seq_hw_unsubscribe_port(snd_seq_t *seq, snd_seq_port_subscribe_t 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; @@ -188,8 +188,8 @@ static int snd_seq_hw_query_port_subscribers(snd_seq_t *seq, snd_seq_query_subs_ 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; @@ -198,8 +198,8 @@ static int snd_seq_hw_get_queue_status(snd_seq_t *seq, snd_seq_queue_status_t * 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; @@ -208,8 +208,8 @@ static int snd_seq_hw_get_queue_tempo(snd_seq_t *seq, snd_seq_queue_tempo_t * te 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; @@ -218,8 +218,8 @@ static int snd_seq_hw_set_queue_tempo(snd_seq_t *seq, snd_seq_queue_tempo_t * te 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; @@ -228,8 +228,8 @@ static int snd_seq_hw_get_queue_owner(snd_seq_t *seq, snd_seq_queue_owner_t * ow 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; @@ -238,8 +238,8 @@ static int snd_seq_hw_set_queue_owner(snd_seq_t *seq, snd_seq_queue_owner_t * ow 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; @@ -248,8 +248,8 @@ static int snd_seq_hw_get_queue_timer(snd_seq_t *seq, snd_seq_queue_timer_t * ti 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; @@ -258,8 +258,8 @@ static int snd_seq_hw_set_queue_timer(snd_seq_t *seq, snd_seq_queue_timer_t * ti 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; @@ -268,8 +268,8 @@ static int snd_seq_hw_get_queue_client(snd_seq_t *seq, snd_seq_queue_client_t * 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; @@ -278,8 +278,8 @@ static int snd_seq_hw_set_queue_client(snd_seq_t *seq, snd_seq_queue_client_t * 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; @@ -288,8 +288,8 @@ static int snd_seq_hw_create_queue(snd_seq_t *seq, snd_seq_queue_info_t *info) 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; @@ -298,8 +298,8 @@ static int snd_seq_hw_delete_queue(snd_seq_t *seq, snd_seq_queue_info_t *info) 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; @@ -308,8 +308,8 @@ static int snd_seq_hw_get_queue_info(snd_seq_t *seq, snd_seq_queue_info_t *info) 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; @@ -318,8 +318,8 @@ static int snd_seq_hw_set_queue_info(snd_seq_t *seq, snd_seq_queue_info_t *info) 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; @@ -346,8 +346,8 @@ static ssize_t snd_seq_hw_read(snd_seq_t *seq, void *buf, size_t len) 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; @@ -356,8 +356,8 @@ static int snd_seq_hw_remove_events(snd_seq_t *seq, snd_seq_remove_events_t *rmp 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; @@ -366,8 +366,8 @@ static int snd_seq_hw_get_client_pool(snd_seq_t *seq, snd_seq_client_pool_t *inf 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; @@ -376,8 +376,8 @@ static int snd_seq_hw_set_client_pool(snd_seq_t *seq, snd_seq_client_pool_t *inf 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; @@ -386,8 +386,8 @@ static int snd_seq_hw_query_next_client(snd_seq_t *seq, snd_seq_client_info_t *i 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; @@ -457,20 +457,20 @@ int snd_seq_hw_open(snd_seq_t **handle, char *name, int streams, int mode) 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; } diff --git a/src/seq/seq_midi_event.c b/src/seq/seq_midi_event.c index d5600d71..1ef97ca2 100644 --- a/src/seq/seq_midi_event.c +++ b/src/seq/seq_midi_event.c @@ -228,7 +228,7 @@ int snd_midi_event_encode_byte(snd_midi_event_t *dev, int c, snd_seq_event_t *ev 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; @@ -265,13 +265,13 @@ int snd_midi_event_encode_byte(snd_midi_event_t *dev, int c, snd_seq_event_t *ev 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 */ @@ -355,7 +355,7 @@ long snd_midi_event_decode(snd_midi_event_t *dev, unsigned char *buf, long count 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; @@ -429,7 +429,7 @@ static int extra_decode_ctrl14(snd_midi_event_t *dev, unsigned char *buf, int co 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; @@ -439,7 +439,7 @@ static int extra_decode_ctrl14(snd_midi_event_t *dev, unsigned char *buf, int co } 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]; diff --git a/src/timer/timer.c b/src/timer/timer.c index 2edbb55c..91da9aaf 100644 --- a/src/timer/timer.c +++ b/src/timer/timer.c @@ -28,8 +28,8 @@ #include #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; @@ -42,13 +42,13 @@ int snd_timer_open(snd_timer_t **handle) *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; } @@ -92,7 +92,7 @@ int snd_timer_next_device(snd_timer_t *handle, snd_timer_id_t * tid) 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; } @@ -104,7 +104,7 @@ int snd_timer_select(snd_timer_t *handle, snd_timer_select_t * tselect) 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; } @@ -116,7 +116,7 @@ int snd_timer_info(snd_timer_t *handle, snd_timer_info_t * info) 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; } @@ -128,7 +128,7 @@ int snd_timer_params(snd_timer_t *handle, snd_timer_params_t * params) 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; } @@ -140,7 +140,7 @@ int snd_timer_status(snd_timer_t *handle, snd_timer_status_t * status) 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; } @@ -152,7 +152,7 @@ int snd_timer_start(snd_timer_t *handle) 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; } @@ -164,7 +164,7 @@ int snd_timer_stop(snd_timer_t *handle) 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; } @@ -176,7 +176,7 @@ int snd_timer_continue(snd_timer_t *handle) 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; }