From: Abramo Bagnara Date: Tue, 30 Jan 2001 16:51:26 +0000 (+0000) Subject: Added snd_ prefix to mask and interval. Divided header.h wrappers X-Git-Tag: v1.0.3~1000 X-Git-Url: https://git.alsa-project.org/?a=commitdiff_plain;h=8712ffc6a5e24bc71fc00d167c417ada3885a1fc;p=alsa-lib.git Added snd_ prefix to mask and interval. Divided header.h wrappers --- diff --git a/include/Makefile.am b/include/Makefile.am index 7308f8c4..c4f553fb 100644 --- a/include/Makefile.am +++ b/include/Makefile.am @@ -3,8 +3,9 @@ sysinclude_HEADERS = asoundlib.h # This is the order they will be concatenated into asoundlib.h! # -header_files=header.h version.h global.h input.h output.h error.h control.h mixer.h \ - pcm.h rawmidi.h timer.h hwdep.h seq.h seqmid.h seq_midi_event.h \ +header_files=header.h version.h global.h input.h output.h error.h mixer.h \ + pcm.h rawmidi.h timer.h hwdep.h control.h \ + seq.h seqmid.h seq_midi_event.h \ conv.h instr.h conf.h footer.h noinst_HEADERS=$(header_files) search.h list.h aserver.h local.h diff --git a/include/control.h b/include/control.h index 401bb8ed..4f7535f4 100644 --- a/include/control.h +++ b/include/control.h @@ -5,6 +5,115 @@ * * ****************************************************************************/ +/* sndrv aliasing */ + +typedef struct sndrv_aes_iec958 snd_aes_iec958_t; +typedef union sndrv_digital_audio snd_digital_audio_t; +typedef enum sndrv_card_type snd_card_type; +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; +#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_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 + typedef struct _snd_ctl snd_ctl_t; typedef enum _snd_ctl_type { SND_CTL_TYPE_HW, diff --git a/include/header.h b/include/header.h index 343c9692..a8f1ed05 100644 --- a/include/header.h +++ b/include/header.h @@ -37,65 +37,6 @@ #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 @@ -104,541 +45,3 @@ typedef struct sndrv_xferv snd_xferv_t; #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/include/hwdep.h b/include/hwdep.h index ecd79581..b2ef6738 100644 --- a/include/hwdep.h +++ b/include/hwdep.h @@ -5,6 +5,18 @@ * * ****************************************************************************/ +/* sndrv aliasing */ +typedef enum sndrv_hwdep_type snd_hwdep_type_t; +typedef struct sndrv_hwdep_info snd_hwdep_info_t; +#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_HWDEP_OPEN_READ (O_RDONLY) #define SND_HWDEP_OPEN_WRITE (O_WRONLY) #define SND_HWDEP_OPEN_DUPLEX (O_RDWR) diff --git a/include/pcm.h b/include/pcm.h index 99809d1d..3b0f506d 100644 --- a/include/pcm.h +++ b/include/pcm.h @@ -5,13 +5,154 @@ * * ****************************************************************************/ +/* sndrv aliasing */ +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 enum sndrv_pcm_hw_param snd_pcm_hw_param_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 sndrv_pcm_uframes_t snd_pcm_uframes_t; +typedef sndrv_pcm_sframes_t snd_pcm_sframes_t; +typedef struct timeval snd_timestamp_t; + +typedef struct sndrv_interval snd_interval_t; +typedef struct sndrv_pcm_info snd_pcm_info_t; +typedef struct sndrv_pcm_hw_params snd_pcm_hw_params_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; +#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_PCM_NONBLOCK 0x0001 #define SND_PCM_ASYNC 0x0002 -#ifdef __cplusplus -extern "C" { -#endif - typedef struct _snd_pcm snd_pcm_t; typedef enum _snd_pcm_type { @@ -41,6 +182,10 @@ typedef struct _snd_pcm_channel_area { unsigned int step; /* samples distance in bits */ } snd_pcm_channel_area_t; +#ifdef __cplusplus +extern "C" { +#endif + int snd_pcm_open(snd_pcm_t **pcm, char *name, int stream, int mode); @@ -89,20 +234,20 @@ int snd_pcm_wait(snd_pcm_t *pcm, int timeout); snd_pcm_sframes_t snd_pcm_avail_update(snd_pcm_t *pcm); int snd_pcm_set_avail_min(snd_pcm_t *pcm, snd_pcm_uframes_t size); -typedef struct _mask mask_t; -size_t mask_sizeof(); -void mask_none(mask_t *mask); -void mask_any(mask_t *mask); -void mask_load(mask_t *mask, unsigned int msk); -int mask_empty(const mask_t *mask); -void mask_set(mask_t *mask, unsigned int val); -void mask_reset(mask_t *mask, unsigned int val); -void mask_copy(mask_t *mask, const mask_t *v); -int mask_test(const mask_t *mask, unsigned int val); -void mask_intersect(mask_t *mask, const mask_t *v); -void mask_union(mask_t *mask, const mask_t *v); -int mask_eq(const mask_t *a, const mask_t *b); -int mask_single(const mask_t *mask); +typedef struct _snd_mask snd_mask_t; +size_t snd_mask_sizeof(); +void snd_mask_none(snd_mask_t *mask); +void snd_mask_any(snd_mask_t *mask); +void snd_mask_load(snd_mask_t *mask, unsigned int msk); +int snd_mask_empty(const snd_mask_t *mask); +void snd_mask_set(snd_mask_t *mask, unsigned int val); +void snd_mask_reset(snd_mask_t *mask, unsigned int val); +void snd_mask_copy(snd_mask_t *mask, const snd_mask_t *v); +int snd_mask_test(const snd_mask_t *mask, unsigned int val); +void snd_mask_intersect(snd_mask_t *mask, const snd_mask_t *v); +void snd_mask_union(snd_mask_t *mask, const snd_mask_t *v); +int snd_mask_eq(const snd_mask_t *a, const snd_mask_t *b); +int snd_mask_single(const snd_mask_t *mask); int snd_pcm_hw_params_any(snd_pcm_t *pcm, snd_pcm_hw_params_t *params); int snd_pcm_hw_param_any(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, @@ -130,7 +275,7 @@ int snd_pcm_hw_param_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, int snd_pcm_hw_param_set(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var, unsigned int val, int dir); int snd_pcm_hw_param_mask(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, - snd_pcm_hw_param_t var, const mask_t *mask); + snd_pcm_hw_param_t var, const snd_mask_t *mask); int snd_pcm_hw_param_min_try(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var, unsigned int val, int *dir); @@ -143,13 +288,13 @@ int snd_pcm_hw_param_minmax_try(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int *max, int *maxdir); int snd_pcm_hw_param_set_try(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var, unsigned int val, int dir); -int snd_pcm_hw_param_mask_try(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, - snd_pcm_hw_param_t var, const mask_t *mask); +int snd_pcm_hw_param_snd_mask_try(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, + snd_pcm_hw_param_t var, const snd_mask_t *mask); int snd_pcm_hw_param_value(const snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var, int *dir); -const mask_t *snd_pcm_hw_param_value_mask(const snd_pcm_hw_params_t *params, +const snd_mask_t *snd_pcm_hw_param_value_mask(const snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var); -const interval_t *snd_pcm_hw_param_value_interval(const snd_pcm_hw_params_t *params, +const snd_interval_t *snd_pcm_hw_param_value_interval(const snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var); unsigned int snd_pcm_hw_param_value_min(const snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var, int *dir); diff --git a/include/rawmidi.h b/include/rawmidi.h index f1b1bbc0..b198582f 100644 --- a/include/rawmidi.h +++ b/include/rawmidi.h @@ -5,6 +5,20 @@ * * ****************************************************************************/ +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; +#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_RAWMIDI_OPEN_OUTPUT (1< #include @@ -105,10 +105,10 @@ static inline unsigned int muldiv32(unsigned int a, unsigned int b, return n; } -int interval_refine_min(interval_t *i, unsigned int min, int openmin) +int snd_interval_refine_min(snd_interval_t *i, unsigned int min, int openmin) { int changed = 0; - assert(!interval_empty(i)); + assert(!snd_interval_empty(i)); if (i->min < min) { i->min = min; i->openmin = openmin; @@ -123,17 +123,17 @@ int interval_refine_min(interval_t *i, unsigned int min, int openmin) i->openmin = 0; } } - if (interval_checkempty(i)) { - interval_none(i); + if (snd_interval_checkempty(i)) { + snd_interval_none(i); return -EINVAL; } return changed; } -int interval_refine_max(interval_t *i, unsigned int max, int openmax) +int snd_interval_refine_max(snd_interval_t *i, unsigned int max, int openmax) { int changed = 0; - assert(!interval_empty(i)); + assert(!snd_interval_empty(i)); if (i->max > max) { i->max = max; i->openmax = openmax; @@ -148,18 +148,18 @@ int interval_refine_max(interval_t *i, unsigned int max, int openmax) i->openmax = 0; } } - if (interval_checkempty(i)) { - interval_none(i); + if (snd_interval_checkempty(i)) { + snd_interval_none(i); return -EINVAL; } return changed; } /* r <- v */ -int interval_refine(interval_t *i, const interval_t *v) +int snd_interval_refine(snd_interval_t *i, const snd_interval_t *v) { int changed = 0; - assert(!interval_empty(i)); + assert(!snd_interval_empty(i)); if (i->min < v->min) { i->min = v->min; i->openmin = v->openmin; @@ -191,17 +191,17 @@ int interval_refine(interval_t *i, const interval_t *v) } } else if (!i->openmin && !i->openmax && i->min == i->max) i->integer = 1; - if (interval_checkempty(i)) { - interval_none(i); + if (snd_interval_checkempty(i)) { + snd_interval_none(i); return -EINVAL; } return changed; } -int interval_refine_first(interval_t *i) +int snd_interval_refine_first(snd_interval_t *i) { - assert(!interval_empty(i)); - if (interval_single(i)) + assert(!snd_interval_empty(i)); + if (snd_interval_single(i)) return 0; i->max = i->min; i->openmax = i->openmin; @@ -210,10 +210,10 @@ int interval_refine_first(interval_t *i) return 1; } -int interval_refine_last(interval_t *i) +int snd_interval_refine_last(snd_interval_t *i) { - assert(!interval_empty(i)); - if (interval_single(i)) + assert(!snd_interval_empty(i)); + if (snd_interval_single(i)) return 0; i->min = i->max; i->openmin = i->openmax; @@ -222,20 +222,20 @@ int interval_refine_last(interval_t *i) return 1; } -int interval_refine_set(interval_t *i, unsigned int val) +int snd_interval_refine_set(snd_interval_t *i, unsigned int val) { - interval_t t; + snd_interval_t t; t.empty = 0; t.min = t.max = val; t.openmin = t.openmax = 0; t.integer = 1; - return interval_refine(i, &t); + return snd_interval_refine(i, &t); } -void interval_add(const interval_t *a, const interval_t *b, interval_t *c) +void snd_interval_add(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c) { if (a->empty || b->empty) { - interval_none(c); + snd_interval_none(c); return; } c->empty = 0; @@ -246,10 +246,10 @@ void interval_add(const interval_t *a, const interval_t *b, interval_t *c) c->integer = (a->integer && b->integer); } -void interval_sub(const interval_t *a, const interval_t *b, interval_t *c) +void snd_interval_sub(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c) { if (a->empty || b->empty) { - interval_none(c); + snd_interval_none(c); return; } c->empty = 0; @@ -260,10 +260,10 @@ void interval_sub(const interval_t *a, const interval_t *b, interval_t *c) c->integer = (a->integer && b->integer); } -void interval_mul(const interval_t *a, const interval_t *b, interval_t *c) +void snd_interval_mul(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c) { if (a->empty || b->empty) { - interval_none(c); + snd_interval_none(c); return; } c->empty = 0; @@ -274,11 +274,11 @@ void interval_mul(const interval_t *a, const interval_t *b, interval_t *c) c->integer = (a->integer && b->integer); } -void interval_div(const interval_t *a, const interval_t *b, interval_t *c) +void snd_interval_div(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c) { unsigned int r; if (a->empty || b->empty) { - interval_none(c); + snd_interval_none(c); return; } c->empty = 0; @@ -299,12 +299,12 @@ void interval_div(const interval_t *a, const interval_t *b, interval_t *c) } /* a * b / c */ -void interval_muldiv(const interval_t *a, const interval_t *b, - const interval_t *c, interval_t *d) +void snd_interval_muldiv(const snd_interval_t *a, const snd_interval_t *b, + const snd_interval_t *c, snd_interval_t *d) { unsigned int r; if (a->empty || b->empty || c->empty) { - interval_none(d); + snd_interval_none(d); return; } d->empty = 0; @@ -320,12 +320,12 @@ void interval_muldiv(const interval_t *a, const interval_t *b, } /* a * b / k */ -void interval_muldivk(const interval_t *a, const interval_t *b, - unsigned int k, interval_t *c) +void snd_interval_muldivk(const snd_interval_t *a, const snd_interval_t *b, + unsigned int k, snd_interval_t *c) { unsigned int r; if (a->empty || b->empty) { - interval_none(c); + snd_interval_none(c); return; } c->empty = 0; @@ -341,12 +341,12 @@ void interval_muldivk(const interval_t *a, const interval_t *b, } /* a * k / b */ -void interval_mulkdiv(const interval_t *a, unsigned int k, - const interval_t *b, interval_t *c) +void snd_interval_mulkdiv(const snd_interval_t *a, unsigned int k, + const snd_interval_t *b, snd_interval_t *c) { unsigned int r; if (a->empty || b->empty) { - interval_none(c); + snd_interval_none(c); return; } c->empty = 0; @@ -366,15 +366,15 @@ void interval_mulkdiv(const interval_t *a, unsigned int k, c->integer = 0; } -void interval_print(const interval_t *i, snd_output_t *out) +void snd_interval_print(const snd_interval_t *i, snd_output_t *out) { - if (interval_empty(i)) + if (snd_interval_empty(i)) snd_output_printf(out, "NONE"); else if (i->min == 0 && i->openmin == 0 && i->max == UINT_MAX && i->openmax == 0) snd_output_printf(out, "ALL"); - else if (interval_single(i) && i->integer) - snd_output_printf(out, "%u", interval_value(i)); + else if (snd_interval_single(i) && i->integer) + snd_output_printf(out, "%u", snd_interval_value(i)); else snd_output_printf(out, "%c%u %u%c", i->openmin ? '(' : '[', diff --git a/src/pcm/interval.h b/src/pcm/interval.h index 3d57f3a8..6014ffd2 100644 --- a/src/pcm/interval.h +++ b/src/pcm/interval.h @@ -21,42 +21,42 @@ #include -#ifdef INTERVAL_INLINE +#ifdef SND_INTERVAL_INLINE #include "interval_inline.h" #else -void interval_any(interval_t *i); -void interval_none(interval_t *i); -int interval_setinteger(interval_t *i); -int interval_empty(const interval_t *i); -int interval_single(const interval_t *i); -int interval_value(const interval_t *i); -int interval_min(const interval_t *i); -int interval_max(const interval_t *i); -int interval_test(const interval_t *i, unsigned int val); -void interval_copy(interval_t *dst, const interval_t *src); -void interval_floor(interval_t *i); -void interval_unfloor(interval_t *i); -int interval_always_eq(const interval_t *i1, const interval_t *i2); -int interval_never_eq(const interval_t *i1, const interval_t *i2); +void snd_interval_any(snd_interval_t *i); +void snd_interval_none(snd_interval_t *i); +int snd_interval_setinteger(snd_interval_t *i); +int snd_interval_empty(const snd_interval_t *i); +int snd_interval_single(const snd_interval_t *i); +int snd_interval_value(const snd_interval_t *i); +int snd_interval_min(const snd_interval_t *i); +int snd_interval_max(const snd_interval_t *i); +int snd_interval_test(const snd_interval_t *i, unsigned int val); +void snd_interval_copy(snd_interval_t *dst, const snd_interval_t *src); +void snd_interval_floor(snd_interval_t *i); +void snd_interval_unfloor(snd_interval_t *i); +int snd_interval_always_eq(const snd_interval_t *i1, const snd_interval_t *i2); +int snd_interval_never_eq(const snd_interval_t *i1, const snd_interval_t *i2); #endif -void interval_add(const interval_t *a, const interval_t *b, interval_t *c); -void interval_sub(const interval_t *a, const interval_t *b, interval_t *c); -void interval_mul(const interval_t *a, const interval_t *b, interval_t *c); -void interval_div(const interval_t *a, const interval_t *b, interval_t *c); -void interval_muldiv(const interval_t *a, const interval_t *b, - const interval_t *c, interval_t *d); -void interval_muldivk(const interval_t *a, const interval_t *b, - unsigned int k, interval_t *c); -void interval_mulkdiv(const interval_t *a, unsigned int k, - const interval_t *b, interval_t *c); -void interval_print(const interval_t *i, snd_output_t *out); -int interval_refine_min(interval_t *i, unsigned int min, int openmin); -int interval_refine_max(interval_t *i, unsigned int max, int openmax); -int interval_refine(interval_t *i, const interval_t *v); -int interval_refine_first(interval_t *i); -int interval_refine_last(interval_t *i); -int interval_refine_set(interval_t *i, unsigned int val); +void snd_interval_add(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c); +void snd_interval_sub(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c); +void snd_interval_mul(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c); +void snd_interval_div(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c); +void snd_interval_muldiv(const snd_interval_t *a, const snd_interval_t *b, + const snd_interval_t *c, snd_interval_t *d); +void snd_interval_muldivk(const snd_interval_t *a, const snd_interval_t *b, + unsigned int k, snd_interval_t *c); +void snd_interval_mulkdiv(const snd_interval_t *a, unsigned int k, + const snd_interval_t *b, snd_interval_t *c); +void snd_interval_print(const snd_interval_t *i, snd_output_t *out); +int snd_interval_refine_min(snd_interval_t *i, unsigned int min, int openmin); +int snd_interval_refine_max(snd_interval_t *i, unsigned int max, int openmax); +int snd_interval_refine(snd_interval_t *i, const snd_interval_t *v); +int snd_interval_refine_first(snd_interval_t *i); +int snd_interval_refine_last(snd_interval_t *i); +int snd_interval_refine_set(snd_interval_t *i, unsigned int val); void boundary_sub(int a, int adir, int b, int bdir, int *c, int *cdir); int boundary_lt(unsigned int a, int adir, unsigned int b, int bdir); int boundary_nearer(int min, int mindir, int best, int bestdir, int max, int maxdir); diff --git a/src/pcm/interval_inline.h b/src/pcm/interval_inline.h index a26d8837..eb0245a6 100644 --- a/src/pcm/interval_inline.h +++ b/src/pcm/interval_inline.h @@ -19,13 +19,13 @@ * */ -#ifdef INTERVAL_C +#ifdef SND_INTERVAL_C #define INLINE inline #else #define INLINE extern inline #endif -INLINE void interval_any(interval_t *i) +INLINE void snd_interval_any(snd_interval_t *i) { i->min = 0; i->openmin = 0; @@ -35,59 +35,59 @@ INLINE void interval_any(interval_t *i) i->empty = 0; } -INLINE void interval_none(interval_t *i) +INLINE void snd_interval_none(snd_interval_t *i) { i->empty = 1; } -INLINE int interval_checkempty(const interval_t *i) +INLINE int snd_interval_checkempty(const snd_interval_t *i) { return (i->min > i->max || (i->min == i->max && (i->openmin || i->openmax))); } -INLINE int interval_empty(const interval_t *i) +INLINE int snd_interval_empty(const snd_interval_t *i) { return i->empty; } -INLINE int interval_single(const interval_t *i) +INLINE int snd_interval_single(const snd_interval_t *i) { - assert(!interval_empty(i)); + assert(!snd_interval_empty(i)); return (i->min == i->max || (i->min + 1 == i->max && i->openmax)); } -INLINE int interval_value(const interval_t *i) +INLINE int snd_interval_value(const snd_interval_t *i) { - assert(interval_single(i)); + assert(snd_interval_single(i)); return i->min; } -INLINE int interval_min(const interval_t *i) +INLINE int snd_interval_min(const snd_interval_t *i) { - assert(!interval_empty(i)); + assert(!snd_interval_empty(i)); return i->min; } -INLINE int interval_max(const interval_t *i) +INLINE int snd_interval_max(const snd_interval_t *i) { - assert(!interval_empty(i)); + assert(!snd_interval_empty(i)); return i->max; } -INLINE int interval_test(const interval_t *i, unsigned int val) +INLINE int snd_interval_test(const snd_interval_t *i, unsigned int val) { return !((i->min > val || (i->min == val && i->openmin) || i->max < val || (i->max == val && i->openmax))); } -INLINE void interval_copy(interval_t *d, const interval_t *s) +INLINE void snd_interval_copy(snd_interval_t *d, const snd_interval_t *s) { *d = *s; } -INLINE int interval_setinteger(interval_t *i) +INLINE int snd_interval_setinteger(snd_interval_t *i) { if (i->integer) return 0; @@ -97,9 +97,9 @@ INLINE int interval_setinteger(interval_t *i) return 1; } -INLINE void interval_floor(interval_t *i) +INLINE void snd_interval_floor(snd_interval_t *i) { - if (i->integer || interval_empty(i)) + if (i->integer || snd_interval_empty(i)) return; i->openmin = 0; if (i->openmax) { @@ -109,9 +109,9 @@ INLINE void interval_floor(interval_t *i) i->integer = 1; } -INLINE void interval_unfloor(interval_t *i) +INLINE void snd_interval_unfloor(snd_interval_t *i) { - if (interval_empty(i)) + if (snd_interval_empty(i)) return; if (i->max == UINT_MAX) return; @@ -123,13 +123,13 @@ INLINE void interval_unfloor(interval_t *i) } -INLINE int interval_always_eq(const interval_t *i1, const interval_t *i2) +INLINE int snd_interval_always_eq(const snd_interval_t *i1, const snd_interval_t *i2) { - return interval_single(i1) && interval_single(i2) && - interval_value(i1) == interval_value(i2); + return snd_interval_single(i1) && snd_interval_single(i2) && + snd_interval_value(i1) == snd_interval_value(i2); } -INLINE int interval_never_eq(const interval_t *i1, const interval_t *i2) +INLINE int snd_interval_never_eq(const snd_interval_t *i1, const snd_interval_t *i2) { return (i1->max < i2->min || diff --git a/src/pcm/mask.c b/src/pcm/mask.c index 68c2fa4c..b650abd8 100644 --- a/src/pcm/mask.c +++ b/src/pcm/mask.c @@ -19,8 +19,8 @@ * */ -#define MASK_C -#define MASK_INLINE +#define SND_MASK_C +#define SND_MASK_INLINE #include #include diff --git a/src/pcm/mask.h b/src/pcm/mask.h index b6e6792c..6a10c9a5 100644 --- a/src/pcm/mask.h +++ b/src/pcm/mask.h @@ -25,37 +25,37 @@ #include #include "asoundlib.h" -#define MASK_MAX 31 +#define SND_MASK_MAX 31 -#ifdef MASK_INLINE +#ifdef SND_MASK_INLINE #include "mask_inline.h" #else -void mask_none(mask_t *mask); -void mask_any(mask_t *mask); -void mask_load(mask_t *mask, unsigned int msk); -int mask_empty(const mask_t *mask); -int mask_full(const mask_t *mask); -void mask_set(mask_t *mask, unsigned int val); -void mask_reset(mask_t *mask, unsigned int val); -void mask_copy(mask_t *mask, const mask_t *v); -int mask_test(const mask_t *mask, unsigned int val); -void mask_intersect(mask_t *mask, const mask_t *v); -void mask_union(mask_t *mask, const mask_t *v); -unsigned int mask_count(const mask_t *mask); -unsigned int mask_min(const mask_t *mask); -unsigned int mask_max(const mask_t *mask); -void mask_set_range(mask_t *mask, unsigned int from, unsigned int to); -void mask_reset_range(mask_t *mask, unsigned int from, unsigned int to); -void mask_leave(mask_t *mask, unsigned int val); -int mask_eq(const mask_t *mask, const mask_t *v); -int mask_single(const mask_t *mask); -int mask_refine(mask_t *mask, const mask_t *v); -int mask_refine_first(mask_t *mask); -int mask_refine_last(mask_t *mask); -int mask_refine_min(mask_t *mask, unsigned int val); -int mask_refine_max(mask_t *mask, unsigned int val); -int mask_refine_set(mask_t *mask, unsigned int val); -int mask_value(const mask_t *mask); -int mask_always_eq(const mask_t *m1, const mask_t *m2); -int mask_never_eq(const mask_t *m1, const mask_t *m2); +void snd_mask_none(snd_mask_t *mask); +void snd_mask_any(snd_mask_t *mask); +void snd_mask_load(snd_mask_t *mask, unsigned int msk); +int snd_mask_empty(const snd_mask_t *mask); +int snd_mask_full(const snd_mask_t *mask); +void snd_mask_set(snd_mask_t *mask, unsigned int val); +void snd_mask_reset(snd_mask_t *mask, unsigned int val); +void snd_mask_copy(snd_mask_t *mask, const snd_mask_t *v); +int snd_mask_test(const snd_mask_t *mask, unsigned int val); +void snd_mask_intersect(snd_mask_t *mask, const snd_mask_t *v); +void snd_mask_union(snd_mask_t *mask, const snd_mask_t *v); +unsigned int snd_mask_count(const snd_mask_t *mask); +unsigned int snd_mask_min(const snd_mask_t *mask); +unsigned int snd_mask_max(const snd_mask_t *mask); +void snd_mask_set_range(snd_mask_t *mask, unsigned int from, unsigned int to); +void snd_mask_reset_range(snd_mask_t *mask, unsigned int from, unsigned int to); +void snd_mask_leave(snd_mask_t *mask, unsigned int val); +int snd_mask_eq(const snd_mask_t *mask, const snd_mask_t *v); +int snd_mask_single(const snd_mask_t *mask); +int snd_mask_refine(snd_mask_t *mask, const snd_mask_t *v); +int snd_mask_refine_first(snd_mask_t *mask); +int snd_mask_refine_last(snd_mask_t *mask); +int snd_mask_refine_min(snd_mask_t *mask, unsigned int val); +int snd_mask_refine_max(snd_mask_t *mask, unsigned int val); +int snd_mask_refine_set(snd_mask_t *mask, unsigned int val); +int snd_mask_value(const snd_mask_t *mask); +int snd_mask_always_eq(const snd_mask_t *m1, const snd_mask_t *m2); +int snd_mask_never_eq(const snd_mask_t *m1, const snd_mask_t *m2); #endif diff --git a/src/pcm/mask_inline.h b/src/pcm/mask_inline.h index 5f3e1a1a..d68db00b 100644 --- a/src/pcm/mask_inline.h +++ b/src/pcm/mask_inline.h @@ -22,7 +22,7 @@ #include #include -#ifdef MASK_C +#ifdef SND_MASK_C #define INLINE inline #else #define INLINE extern inline @@ -32,11 +32,11 @@ #define MASK_MAX 31 #endif -struct _mask { +struct _snd_mask { unsigned int bits; }; -#define mask_bits(mask) ((mask)->bits) +#define snd_mask_bits(mask) ((mask)->bits) INLINE unsigned int ld2(u_int32_t v) { @@ -72,190 +72,190 @@ INLINE unsigned int hweight32(u_int32_t v) return (v & 0x0000FFFF) + ((v >> 16) & 0x0000FFFF); } -INLINE size_t mask_sizeof(void) +INLINE size_t snd_mask_sizeof(void) { - return sizeof(mask_t); + return sizeof(snd_mask_t); } -INLINE void mask_none(mask_t *mask) +INLINE void snd_mask_none(snd_mask_t *mask) { - mask_bits(mask) = 0; + snd_mask_bits(mask) = 0; } -INLINE void mask_any(mask_t *mask) +INLINE void snd_mask_any(snd_mask_t *mask) { - mask_bits(mask) = ~0U; + snd_mask_bits(mask) = ~0U; } -INLINE void mask_load(mask_t *mask, unsigned int msk) +INLINE void snd_mask_load(snd_mask_t *mask, unsigned int msk) { - mask_bits(mask) = msk; + snd_mask_bits(mask) = msk; } -INLINE int mask_empty(const mask_t *mask) +INLINE int snd_mask_empty(const snd_mask_t *mask) { - return mask_bits(mask) == 0; + return snd_mask_bits(mask) == 0; } -INLINE int mask_full(const mask_t *mask) +INLINE int snd_mask_full(const snd_mask_t *mask) { - return mask_bits(mask) == ~0U; + return snd_mask_bits(mask) == ~0U; } -INLINE unsigned int mask_count(const mask_t *mask) +INLINE unsigned int snd_mask_count(const snd_mask_t *mask) { - return hweight32(mask_bits(mask)); + return hweight32(snd_mask_bits(mask)); } -INLINE unsigned int mask_min(const mask_t *mask) +INLINE unsigned int snd_mask_min(const snd_mask_t *mask) { - assert(!mask_empty(mask)); - return ffs(mask_bits(mask)) - 1; + assert(!snd_mask_empty(mask)); + return ffs(snd_mask_bits(mask)) - 1; } -INLINE unsigned int mask_max(const mask_t *mask) +INLINE unsigned int snd_mask_max(const snd_mask_t *mask) { - assert(!mask_empty(mask)); - return ld2(mask_bits(mask)); + assert(!snd_mask_empty(mask)); + return ld2(snd_mask_bits(mask)); } -INLINE void mask_set(mask_t *mask, unsigned int val) +INLINE void snd_mask_set(snd_mask_t *mask, unsigned int val) { - assert(val <= MASK_MAX); - mask_bits(mask) |= (1U << val); + assert(val <= SND_MASK_MAX); + snd_mask_bits(mask) |= (1U << val); } -INLINE void mask_reset(mask_t *mask, unsigned int val) +INLINE void snd_mask_reset(snd_mask_t *mask, unsigned int val) { - assert(val <= MASK_MAX); - mask_bits(mask) &= ~(1U << val); + assert(val <= SND_MASK_MAX); + snd_mask_bits(mask) &= ~(1U << val); } -INLINE void mask_set_range(mask_t *mask, unsigned int from, unsigned int to) +INLINE void snd_mask_set_range(snd_mask_t *mask, unsigned int from, unsigned int to) { - assert(to <= MASK_MAX && from <= to); - mask_bits(mask) |= ((1U << (from - to + 1)) - 1) << from; + assert(to <= SND_MASK_MAX && from <= to); + snd_mask_bits(mask) |= ((1U << (from - to + 1)) - 1) << from; } -INLINE void mask_reset_range(mask_t *mask, unsigned int from, unsigned int to) +INLINE void snd_mask_reset_range(snd_mask_t *mask, unsigned int from, unsigned int to) { - assert(to <= MASK_MAX && from <= to); - mask_bits(mask) &= ~(((1U << (from - to + 1)) - 1) << from); + assert(to <= SND_MASK_MAX && from <= to); + snd_mask_bits(mask) &= ~(((1U << (from - to + 1)) - 1) << from); } -INLINE void mask_leave(mask_t *mask, unsigned int val) +INLINE void snd_mask_leave(snd_mask_t *mask, unsigned int val) { - assert(val <= MASK_MAX); - mask_bits(mask) &= 1U << val; + assert(val <= SND_MASK_MAX); + snd_mask_bits(mask) &= 1U << val; } -INLINE void mask_intersect(mask_t *mask, const mask_t *v) +INLINE void snd_mask_intersect(snd_mask_t *mask, const snd_mask_t *v) { - mask_bits(mask) &= mask_bits(v); + snd_mask_bits(mask) &= snd_mask_bits(v); } -INLINE void mask_union(mask_t *mask, const mask_t *v) +INLINE void snd_mask_union(snd_mask_t *mask, const snd_mask_t *v) { - mask_bits(mask) |= mask_bits(v); + snd_mask_bits(mask) |= snd_mask_bits(v); } -INLINE int mask_eq(const mask_t *mask, const mask_t *v) +INLINE int snd_mask_eq(const snd_mask_t *mask, const snd_mask_t *v) { - return mask_bits(mask) == mask_bits(v); + return snd_mask_bits(mask) == snd_mask_bits(v); } -INLINE void mask_copy(mask_t *mask, const mask_t *v) +INLINE void snd_mask_copy(snd_mask_t *mask, const snd_mask_t *v) { - mask_bits(mask) = mask_bits(v); + snd_mask_bits(mask) = snd_mask_bits(v); } -INLINE int mask_test(const mask_t *mask, unsigned int val) +INLINE int snd_mask_test(const snd_mask_t *mask, unsigned int val) { - assert(val <= MASK_MAX); - return mask_bits(mask) & (1U << val); + assert(val <= SND_MASK_MAX); + return snd_mask_bits(mask) & (1U << val); } -INLINE int mask_single(const mask_t *mask) +INLINE int snd_mask_single(const snd_mask_t *mask) { - assert(!mask_empty(mask)); - return !(mask_bits(mask) & (mask_bits(mask) - 1)); + assert(!snd_mask_empty(mask)); + return !(snd_mask_bits(mask) & (snd_mask_bits(mask) - 1)); } -INLINE int mask_refine(mask_t *mask, const mask_t *v) +INLINE int snd_mask_refine(snd_mask_t *mask, const snd_mask_t *v) { - mask_t old; - assert(!mask_empty(mask)); - mask_copy(&old, mask); - mask_intersect(mask, v); - if (mask_empty(mask)) + snd_mask_t old; + assert(!snd_mask_empty(mask)); + snd_mask_copy(&old, mask); + snd_mask_intersect(mask, v); + if (snd_mask_empty(mask)) return -EINVAL; - return !mask_eq(mask, &old); + return !snd_mask_eq(mask, &old); } -INLINE int mask_refine_first(mask_t *mask) +INLINE int snd_mask_refine_first(snd_mask_t *mask) { - assert(!mask_empty(mask)); - if (mask_single(mask)) + assert(!snd_mask_empty(mask)); + if (snd_mask_single(mask)) return 0; - mask_leave(mask, mask_min(mask)); + snd_mask_leave(mask, snd_mask_min(mask)); return 1; } -INLINE int mask_refine_last(mask_t *mask) +INLINE int snd_mask_refine_last(snd_mask_t *mask) { - assert(!mask_empty(mask)); - if (mask_single(mask)) + assert(!snd_mask_empty(mask)); + if (snd_mask_single(mask)) return 0; - mask_leave(mask, mask_max(mask)); + snd_mask_leave(mask, snd_mask_max(mask)); return 1; } -INLINE int mask_refine_min(mask_t *mask, unsigned int val) +INLINE int snd_mask_refine_min(snd_mask_t *mask, unsigned int val) { - assert(!mask_empty(mask)); - if (mask_min(mask) >= val) + assert(!snd_mask_empty(mask)); + if (snd_mask_min(mask) >= val) return 0; - mask_reset_range(mask, 0, val - 1); - if (mask_empty(mask)) + snd_mask_reset_range(mask, 0, val - 1); + if (snd_mask_empty(mask)) return -EINVAL; return 1; } -INLINE int mask_refine_max(mask_t *mask, unsigned int val) +INLINE int snd_mask_refine_max(snd_mask_t *mask, unsigned int val) { - assert(!mask_empty(mask)); - if (mask_max(mask) <= val) + assert(!snd_mask_empty(mask)); + if (snd_mask_max(mask) <= val) return 0; - mask_reset_range(mask, val + 1, MASK_MAX); - if (mask_empty(mask)) + snd_mask_reset_range(mask, val + 1, SND_MASK_MAX); + if (snd_mask_empty(mask)) return -EINVAL; return 1; } -INLINE int mask_refine_set(mask_t *mask, unsigned int val) +INLINE int snd_mask_refine_set(snd_mask_t *mask, unsigned int val) { int changed; - assert(!mask_empty(mask)); - changed = !mask_single(mask); - mask_leave(mask, val); - if (mask_empty(mask)) + assert(!snd_mask_empty(mask)); + changed = !snd_mask_single(mask); + snd_mask_leave(mask, val); + if (snd_mask_empty(mask)) return -EINVAL; return changed; } -INLINE int mask_value(const mask_t *mask) +INLINE int snd_mask_value(const snd_mask_t *mask) { - assert(!mask_empty(mask)); - return mask_min(mask); + assert(!snd_mask_empty(mask)); + return snd_mask_min(mask); } -INLINE int mask_always_eq(const mask_t *m1, const mask_t *m2) +INLINE int snd_mask_always_eq(const snd_mask_t *m1, const snd_mask_t *m2) { - return mask_single(m1) && mask_single(m2) && - mask_value(m1) == mask_value(m2); + return snd_mask_single(m1) && snd_mask_single(m2) && + snd_mask_value(m1) == snd_mask_value(m2); } -INLINE int mask_never_eq(const mask_t *m1, const mask_t *m2) +INLINE int snd_mask_never_eq(const snd_mask_t *m1, const snd_mask_t *m2) { - return (mask_bits(m1) & mask_bits(m2)) == 0; + return (snd_mask_bits(m1) & snd_mask_bits(m2)) == 0; } diff --git a/src/pcm/pcm_adpcm.c b/src/pcm/pcm_adpcm.c index e8ce9663..0dde7fbd 100644 --- a/src/pcm/pcm_adpcm.c +++ b/src/pcm/pcm_adpcm.c @@ -316,15 +316,15 @@ static int snd_pcm_adpcm_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t { snd_pcm_adpcm_t *adpcm = pcm->private; int err; - mask_t *access_mask = alloca(mask_sizeof()); - mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN); + snd_mask_t *access_mask = alloca(snd_mask_sizeof()); + snd_mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN); err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS, access_mask); if (err < 0) return err; if (adpcm->sformat == SND_PCM_FORMAT_IMA_ADPCM) { - mask_t *format_mask = alloca(mask_sizeof()); - mask_load(format_mask, SND_PCM_FMTBIT_LINEAR); + snd_mask_t *format_mask = alloca(snd_mask_sizeof()); + snd_mask_load(format_mask, SND_PCM_FMTBIT_LINEAR); err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_FORMAT, format_mask); } else { @@ -345,8 +345,8 @@ static int snd_pcm_adpcm_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t static int snd_pcm_adpcm_hw_refine_sprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *sparams) { snd_pcm_adpcm_t *adpcm = pcm->private; - mask_t *saccess_mask = alloca(mask_sizeof()); - mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP); + snd_mask_t *saccess_mask = alloca(snd_mask_sizeof()); + snd_mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP); _snd_pcm_hw_params_any(sparams); _snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS, saccess_mask); diff --git a/src/pcm/pcm_alaw.c b/src/pcm/pcm_alaw.c index b211cc06..8d8d569b 100644 --- a/src/pcm/pcm_alaw.c +++ b/src/pcm/pcm_alaw.c @@ -215,15 +215,15 @@ static int snd_pcm_alaw_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t * { snd_pcm_alaw_t *alaw = pcm->private; int err; - mask_t *access_mask = alloca(mask_sizeof()); - mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN); + snd_mask_t *access_mask = alloca(snd_mask_sizeof()); + snd_mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN); err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS, access_mask); if (err < 0) return err; if (alaw->sformat == SND_PCM_FORMAT_A_LAW) { - mask_t *format_mask = alloca(mask_sizeof()); - mask_load(format_mask, SND_PCM_FMTBIT_LINEAR); + snd_mask_t *format_mask = alloca(snd_mask_sizeof()); + snd_mask_load(format_mask, SND_PCM_FMTBIT_LINEAR); err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_FORMAT, format_mask); } else { @@ -244,8 +244,8 @@ static int snd_pcm_alaw_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t * static int snd_pcm_alaw_hw_refine_sprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *sparams) { snd_pcm_alaw_t *alaw = pcm->private; - mask_t *saccess_mask = alloca(mask_sizeof()); - mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP); + snd_mask_t *saccess_mask = alloca(snd_mask_sizeof()); + snd_mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP); _snd_pcm_hw_params_any(sparams); _snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS, saccess_mask); diff --git a/src/pcm/pcm_copy.c b/src/pcm/pcm_copy.c index d5c5e9a9..0d4f7e7c 100644 --- a/src/pcm/pcm_copy.c +++ b/src/pcm/pcm_copy.c @@ -31,8 +31,8 @@ typedef struct { static int snd_pcm_copy_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *params) { int err; - mask_t *access_mask = alloca(mask_sizeof()); - mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN); + snd_mask_t *access_mask = alloca(snd_mask_sizeof()); + snd_mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN); err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS, access_mask); if (err < 0) @@ -43,8 +43,8 @@ static int snd_pcm_copy_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_ static int snd_pcm_copy_hw_refine_sprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *sparams) { - mask_t *saccess_mask = alloca(mask_sizeof()); - mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP); + snd_mask_t *saccess_mask = alloca(snd_mask_sizeof()); + snd_mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP); _snd_pcm_hw_params_any(sparams); _snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS, saccess_mask); diff --git a/src/pcm/pcm_hw.c b/src/pcm/pcm_hw.c index 2f12353f..aaae5d3e 100644 --- a/src/pcm/pcm_hw.c +++ b/src/pcm/pcm_hw.c @@ -44,8 +44,8 @@ typedef struct { int fd; int card, device, subdevice; - volatile snd_pcm_mmap_status_t *mmap_status; - snd_pcm_mmap_control_t *mmap_control; + volatile struct sndrv_pcm_mmap_status *mmap_status; + struct sndrv_pcm_mmap_control *mmap_control; int shmid; } snd_pcm_hw_t; @@ -318,7 +318,7 @@ static snd_pcm_sframes_t snd_pcm_hw_writei(snd_pcm_t *pcm, const void *buffer, s snd_pcm_sframes_t result; snd_pcm_hw_t *hw = pcm->private; int fd = hw->fd; - snd_xferi_t xferi; + struct sndrv_xferi xferi; xferi.buf = (char*) buffer; xferi.frames = size; result = ioctl(fd, SNDRV_PCM_IOCTL_WRITEI_FRAMES, &xferi); @@ -332,7 +332,7 @@ static snd_pcm_sframes_t snd_pcm_hw_writen(snd_pcm_t *pcm, void **bufs, snd_pcm_ snd_pcm_sframes_t result; snd_pcm_hw_t *hw = pcm->private; int fd = hw->fd; - snd_xfern_t xfern; + struct sndrv_xfern xfern; xfern.bufs = bufs; xfern.frames = size; result = ioctl(fd, SNDRV_PCM_IOCTL_WRITEN_FRAMES, &xfern); @@ -346,7 +346,7 @@ static snd_pcm_sframes_t snd_pcm_hw_readi(snd_pcm_t *pcm, void *buffer, snd_pcm_ snd_pcm_sframes_t result; snd_pcm_hw_t *hw = pcm->private; int fd = hw->fd; - snd_xferi_t xferi; + struct sndrv_xferi xferi; xferi.buf = buffer; xferi.frames = size; result = ioctl(fd, SNDRV_PCM_IOCTL_READI_FRAMES, &xferi); @@ -360,7 +360,7 @@ snd_pcm_sframes_t snd_pcm_hw_readn(snd_pcm_t *pcm, void **bufs, snd_pcm_uframes_ snd_pcm_sframes_t result; snd_pcm_hw_t *hw = pcm->private; int fd = hw->fd; - snd_xfern_t xfern; + struct sndrv_xfern xfern; xfern.bufs = bufs; xfern.frames = size; result = ioctl(fd, SNDRV_PCM_IOCTL_READN_FRAMES, &xfern); @@ -373,7 +373,7 @@ static int snd_pcm_hw_mmap_status(snd_pcm_t *pcm) { snd_pcm_hw_t *hw = pcm->private; void *ptr; - ptr = mmap(NULL, PAGE_ALIGN(sizeof(snd_pcm_mmap_status_t)), PROT_READ, MAP_FILE|MAP_SHARED, + ptr = mmap(NULL, PAGE_ALIGN(sizeof(struct sndrv_pcm_mmap_status)), PROT_READ, MAP_FILE|MAP_SHARED, hw->fd, SND_PCM_MMAP_OFFSET_STATUS); if (ptr == MAP_FAILED || ptr == NULL) { SYSERR("status mmap failed"); @@ -388,7 +388,7 @@ static int snd_pcm_hw_mmap_control(snd_pcm_t *pcm) { snd_pcm_hw_t *hw = pcm->private; void *ptr; - ptr = mmap(NULL, PAGE_ALIGN(sizeof(snd_pcm_mmap_control_t)), PROT_READ|PROT_WRITE, MAP_FILE|MAP_SHARED, + ptr = mmap(NULL, PAGE_ALIGN(sizeof(struct sndrv_pcm_mmap_control)), PROT_READ|PROT_WRITE, MAP_FILE|MAP_SHARED, hw->fd, SND_PCM_MMAP_OFFSET_CONTROL); if (ptr == MAP_FAILED || ptr == NULL) { SYSERR("control mmap failed"); diff --git a/src/pcm/pcm_linear.c b/src/pcm/pcm_linear.c index 0ebb3da3..94382f0f 100644 --- a/src/pcm/pcm_linear.c +++ b/src/pcm/pcm_linear.c @@ -132,10 +132,10 @@ void snd_pcm_linear_convert(const snd_pcm_channel_area_t *src_areas, snd_pcm_ufr static int snd_pcm_linear_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *params) { int err; - mask_t *access_mask = alloca(mask_sizeof()); - mask_t *format_mask = alloca(mask_sizeof()); - mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN); - mask_load(format_mask, SND_PCM_FMTBIT_LINEAR); + snd_mask_t *access_mask = alloca(snd_mask_sizeof()); + snd_mask_t *format_mask = alloca(snd_mask_sizeof()); + snd_mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN); + snd_mask_load(format_mask, SND_PCM_FMTBIT_LINEAR); err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS, access_mask); if (err < 0) @@ -155,8 +155,8 @@ static int snd_pcm_linear_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, sn static int snd_pcm_linear_hw_refine_sprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *sparams) { snd_pcm_linear_t *linear = pcm->private; - mask_t *saccess_mask = alloca(mask_sizeof()); - mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP); + snd_mask_t *saccess_mask = alloca(snd_mask_sizeof()); + snd_mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP); _snd_pcm_hw_params_any(sparams); _snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS, saccess_mask); diff --git a/src/pcm/pcm_local.h b/src/pcm/pcm_local.h index c044c4dd..d59c2b06 100644 --- a/src/pcm/pcm_local.h +++ b/src/pcm/pcm_local.h @@ -332,9 +332,9 @@ void _snd_pcm_hw_param_setempty(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var); int _snd_pcm_hw_param_refine_interval(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var, - const interval_t *val); + const snd_interval_t *val); int _snd_pcm_hw_param_mask(snd_pcm_hw_params_t *params, - unsigned int var, const mask_t *mask); + unsigned int var, const snd_mask_t *mask); int _snd_pcm_hw_param_first(snd_pcm_hw_params_t *params, unsigned int var); int _snd_pcm_hw_param_last(snd_pcm_hw_params_t *params, diff --git a/src/pcm/pcm_mulaw.c b/src/pcm/pcm_mulaw.c index 2f341b1f..8ca337f6 100644 --- a/src/pcm/pcm_mulaw.c +++ b/src/pcm/pcm_mulaw.c @@ -232,15 +232,15 @@ static int snd_pcm_mulaw_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t { snd_pcm_mulaw_t *mulaw = pcm->private; int err; - mask_t *access_mask = alloca(mask_sizeof()); - mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN); + snd_mask_t *access_mask = alloca(snd_mask_sizeof()); + snd_mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN); err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS, access_mask); if (err < 0) return err; if (mulaw->sformat == SND_PCM_FORMAT_MU_LAW) { - mask_t *format_mask = alloca(mask_sizeof()); - mask_load(format_mask, SND_PCM_FMTBIT_LINEAR); + snd_mask_t *format_mask = alloca(snd_mask_sizeof()); + snd_mask_load(format_mask, SND_PCM_FMTBIT_LINEAR); err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_FORMAT, format_mask); } else { @@ -259,8 +259,8 @@ static int snd_pcm_mulaw_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t static int snd_pcm_mulaw_hw_refine_sprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *sparams) { snd_pcm_mulaw_t *mulaw = pcm->private; - mask_t *saccess_mask = alloca(mask_sizeof()); - mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP); + snd_mask_t *saccess_mask = alloca(snd_mask_sizeof()); + snd_mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP); _snd_pcm_hw_params_any(sparams); _snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS, saccess_mask); diff --git a/src/pcm/pcm_multi.c b/src/pcm/pcm_multi.c index 1b8e6274..dcbda540 100644 --- a/src/pcm/pcm_multi.c +++ b/src/pcm/pcm_multi.c @@ -102,10 +102,10 @@ static int snd_pcm_multi_info(snd_pcm_t *pcm, snd_pcm_info_t *info) static int snd_pcm_multi_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *params) { snd_pcm_multi_t *multi = pcm->private; - mask_t *access_mask = alloca(mask_sizeof()); + snd_mask_t *access_mask = alloca(snd_mask_sizeof()); int err; - mask_any(access_mask); - mask_reset(access_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED); + snd_mask_any(access_mask); + snd_mask_reset(access_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED); err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS, access_mask); if (err < 0) @@ -123,8 +123,8 @@ static int snd_pcm_multi_hw_refine_sprepare(snd_pcm_t *pcm, int slave_idx, { snd_pcm_multi_t *multi = pcm->private; snd_pcm_multi_slave_t *slave = &multi->slaves[slave_idx]; - mask_t *saccess_mask = alloca(mask_sizeof()); - mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP); + snd_mask_t *saccess_mask = alloca(snd_mask_sizeof()); + snd_mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP); _snd_pcm_hw_params_any(sparams); _snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS, saccess_mask); @@ -148,13 +148,13 @@ static int snd_pcm_multi_hw_refine_schange(snd_pcm_t *pcm ATTRIBUTE_UNUSED, SND_PCM_HW_PARBIT_BUFFER_SIZE | SND_PCM_HW_PARBIT_BUFFER_TIME | SND_PCM_HW_PARBIT_TICK_TIME); - const mask_t *access_mask = snd_pcm_hw_param_value_mask(params, SND_PCM_HW_PARAM_ACCESS); - if (!mask_test(access_mask, SND_PCM_ACCESS_RW_INTERLEAVED) && - !mask_test(access_mask, SND_PCM_ACCESS_RW_NONINTERLEAVED) && - !mask_test(access_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED)) { - mask_t *saccess_mask = alloca(mask_sizeof()); - mask_any(saccess_mask); - mask_reset(saccess_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED); + const snd_mask_t *access_mask = snd_pcm_hw_param_value_mask(params, SND_PCM_HW_PARAM_ACCESS); + if (!snd_mask_test(access_mask, SND_PCM_ACCESS_RW_INTERLEAVED) && + !snd_mask_test(access_mask, SND_PCM_ACCESS_RW_NONINTERLEAVED) && + !snd_mask_test(access_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED)) { + snd_mask_t *saccess_mask = alloca(snd_mask_sizeof()); + snd_mask_any(saccess_mask); + snd_mask_reset(saccess_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED); err = _snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS, saccess_mask); if (err < 0) @@ -181,15 +181,15 @@ static int snd_pcm_multi_hw_refine_cchange(snd_pcm_t *pcm ATTRIBUTE_UNUSED, SND_PCM_HW_PARBIT_BUFFER_SIZE | SND_PCM_HW_PARBIT_BUFFER_TIME | SND_PCM_HW_PARBIT_TICK_TIME); - mask_t *access_mask = alloca(mask_sizeof()); - const mask_t *saccess_mask = snd_pcm_hw_param_value_mask(sparams, SND_PCM_HW_PARAM_ACCESS); - mask_any(access_mask); - mask_reset(access_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED); - if (!mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED)) - mask_reset(access_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED); - if (!mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_COMPLEX) && - !mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED)) - mask_reset(access_mask, SND_PCM_ACCESS_MMAP_COMPLEX); + snd_mask_t *access_mask = alloca(snd_mask_sizeof()); + const snd_mask_t *saccess_mask = snd_pcm_hw_param_value_mask(sparams, SND_PCM_HW_PARAM_ACCESS); + snd_mask_any(access_mask); + snd_mask_reset(access_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED); + if (!snd_mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED)) + snd_mask_reset(access_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED); + if (!snd_mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_COMPLEX) && + !snd_mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED)) + snd_mask_reset(access_mask, SND_PCM_ACCESS_MMAP_COMPLEX); err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS, access_mask); if (err < 0) diff --git a/src/pcm/pcm_params.c b/src/pcm/pcm_params.c index 772d98b2..181a7fc0 100644 --- a/src/pcm/pcm_params.c +++ b/src/pcm/pcm_params.c @@ -20,8 +20,8 @@ */ #include "pcm_local.h" -#define INTERVAL_INLINE -#define MASK_INLINE +#define SND_INTERVAL_INLINE +#define SND_MASK_INLINE #include "interval.h" #include "mask.h" @@ -37,42 +37,42 @@ static inline int hw_is_interval(int var) var <= SND_PCM_HW_PARAM_LAST_INTERVAL; } -static inline mask_t *hw_param_mask(snd_pcm_hw_params_t *params, +static inline snd_mask_t *hw_param_mask(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var) { assert(hw_is_mask(var)); - return (mask_t*)¶ms->masks[var - SND_PCM_HW_PARAM_FIRST_MASK]; + return (snd_mask_t*)¶ms->masks[var - SND_PCM_HW_PARAM_FIRST_MASK]; } -static inline interval_t *hw_param_interval(snd_pcm_hw_params_t *params, +static inline snd_interval_t *hw_param_interval(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var) { assert(hw_is_interval(var)); return ¶ms->intervals[var - SND_PCM_HW_PARAM_FIRST_INTERVAL]; } -static inline const mask_t *hw_param_mask_c(const snd_pcm_hw_params_t *params, +static inline const snd_mask_t *hw_param_mask_c(const snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var) { - return (const mask_t *)hw_param_mask((snd_pcm_hw_params_t*) params, var); + return (const snd_mask_t *)hw_param_mask((snd_pcm_hw_params_t*) params, var); } -static inline const interval_t *hw_param_interval_c(const snd_pcm_hw_params_t *params, +static inline const snd_interval_t *hw_param_interval_c(const snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var) { - return (const interval_t *)hw_param_interval((snd_pcm_hw_params_t*) params, var); + return (const snd_interval_t *)hw_param_interval((snd_pcm_hw_params_t*) params, var); } void _snd_pcm_hw_param_any(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var) { if (hw_is_mask(var)) { - mask_any(hw_param_mask(params, var)); + snd_mask_any(hw_param_mask(params, var)); params->cmask |= 1 << var; params->rmask |= 1 << var; return; } if (hw_is_interval(var)) { - interval_any(hw_param_interval(params, var)); + snd_interval_any(hw_param_interval(params, var)); params->cmask |= 1 << var; params->rmask |= 1 << var; return; @@ -110,20 +110,20 @@ int snd_pcm_hw_param_value(const snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var, int *dir) { if (hw_is_mask(var)) { - const mask_t *mask = hw_param_mask_c(params, var); - if (!mask_single(mask)) + const snd_mask_t *mask = hw_param_mask_c(params, var); + if (!snd_mask_single(mask)) return -EINVAL; if (dir) *dir = 0; - return mask_value(mask); + return snd_mask_value(mask); } if (hw_is_interval(var)) { - const interval_t *i = hw_param_interval_c(params, var); - if (!interval_single(i)) + const snd_interval_t *i = hw_param_interval_c(params, var); + if (!snd_interval_single(i)) return -EINVAL; if (dir) *dir = i->openmin; - return interval_value(i); + return snd_interval_value(i); } assert(0); return -EINVAL; @@ -136,13 +136,13 @@ unsigned int snd_pcm_hw_param_value_min(const snd_pcm_hw_params_t *params, if (hw_is_mask(var)) { if (dir) *dir = 0; - return mask_min(hw_param_mask_c(params, var)); + return snd_mask_min(hw_param_mask_c(params, var)); } if (hw_is_interval(var)) { - const interval_t *i = hw_param_interval_c(params, var); + const snd_interval_t *i = hw_param_interval_c(params, var); if (dir) *dir = i->openmin; - return interval_min(i); + return snd_interval_min(i); } assert(0); return -EINVAL; @@ -155,13 +155,13 @@ unsigned int snd_pcm_hw_param_value_max(const snd_pcm_hw_params_t *params, if (hw_is_mask(var)) { if (dir) *dir = 0; - return mask_max(hw_param_mask_c(params, var)); + return snd_mask_max(hw_param_mask_c(params, var)); } if (hw_is_interval(var)) { - const interval_t *i = hw_param_interval_c(params, var); + const snd_interval_t *i = hw_param_interval_c(params, var); if (dir) *dir = - (int) i->openmax; - return interval_max(i); + return snd_interval_max(i); } assert(0); return -EINVAL; @@ -170,7 +170,7 @@ unsigned int snd_pcm_hw_param_value_max(const snd_pcm_hw_params_t *params, /* Return the mask for field PAR. This function can be called only for SND_PCM_HW_PARAM_ACCESS, SND_PCM_HW_PARAM_FORMAT, SND_PCM_HW_PARAM_SUBFORMAT. */ -const mask_t *snd_pcm_hw_param_value_mask(const snd_pcm_hw_params_t *params, +const snd_mask_t *snd_pcm_hw_param_value_mask(const snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var) { assert(hw_is_mask(var)); @@ -180,7 +180,7 @@ const mask_t *snd_pcm_hw_param_value_mask(const snd_pcm_hw_params_t *params, /* Return the interval for field PAR. This function cannot be called for SND_PCM_HW_PARAM_ACCESS, SND_PCM_HW_PARAM_FORMAT, SND_PCM_HW_PARAM_SUBFORMAT. */ -const interval_t *snd_pcm_hw_param_value_interval(const snd_pcm_hw_params_t *params, +const snd_interval_t *snd_pcm_hw_param_value_interval(const snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var) { assert(hw_is_interval(var)); @@ -191,11 +191,11 @@ const interval_t *snd_pcm_hw_param_value_interval(const snd_pcm_hw_params_t *par int _snd_pcm_hw_param_refine_interval(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var, - const interval_t *val) + const snd_interval_t *val) { int changed; assert(hw_is_interval(var)); - changed = interval_refine(hw_param_interval(params, var), val); + changed = snd_interval_refine(hw_param_interval(params, var), val); if (changed) { params->cmask |= 1 << var; params->rmask |= 1 << var; @@ -207,11 +207,11 @@ void _snd_pcm_hw_param_setempty(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var) { if (hw_is_mask(var)) { - mask_none(hw_param_mask(params, var)); + snd_mask_none(hw_param_mask(params, var)); params->cmask |= 1 << var; params->rmask |= 1 << var; } else if (hw_is_interval(var)) { - interval_none(hw_param_interval(params, var)); + snd_interval_none(hw_param_interval(params, var)); params->cmask |= 1 << var; params->rmask |= 1 << var; } else { @@ -224,7 +224,7 @@ int _snd_pcm_hw_param_setinteger(snd_pcm_hw_params_t *params, { int changed; assert(hw_is_interval(var)); - changed = interval_setinteger(hw_param_interval(params, var)); + changed = snd_interval_setinteger(hw_param_interval(params, var)); if (changed) { params->cmask |= 1 << var; params->rmask |= 1 << var; @@ -256,9 +256,9 @@ int _snd_pcm_hw_param_first(snd_pcm_hw_params_t *params, { int changed; if (hw_is_mask(var)) - changed = mask_refine_first(hw_param_mask(params, var)); + changed = snd_mask_refine_first(hw_param_mask(params, var)); else if (hw_is_interval(var)) - changed = interval_refine_first(hw_param_interval(params, var)); + changed = snd_interval_refine_first(hw_param_interval(params, var)); else { assert(0); return -EINVAL; @@ -294,9 +294,9 @@ int _snd_pcm_hw_param_last(snd_pcm_hw_params_t *params, { int changed; if (hw_is_mask(var)) - changed = mask_refine_last(hw_param_mask(params, var)); + changed = snd_mask_refine_last(hw_param_mask(params, var)); else if (hw_is_interval(var)) - changed = interval_refine_last(hw_param_interval(params, var)); + changed = snd_interval_refine_last(hw_param_interval(params, var)); else { assert(0); return -EINVAL; @@ -343,9 +343,9 @@ int _snd_pcm_hw_param_min(snd_pcm_hw_params_t *params, } } if (hw_is_mask(var)) - changed = mask_refine_min(hw_param_mask(params, var), val + !!open); + changed = snd_mask_refine_min(hw_param_mask(params, var), val + !!open); else if (hw_is_interval(var)) - changed = interval_refine_min(hw_param_interval(params, var), val, open); + changed = snd_interval_refine_min(hw_param_interval(params, var), val, open); else { assert(0); return -EINVAL; @@ -403,12 +403,12 @@ int _snd_pcm_hw_param_max(snd_pcm_hw_params_t *params, } if (hw_is_mask(var)) { if (val == 0 && open) { - mask_none(hw_param_mask(params, var)); + snd_mask_none(hw_param_mask(params, var)); changed = -EINVAL; } else - changed = mask_refine_max(hw_param_mask(params, var), val - !!open); + changed = snd_mask_refine_max(hw_param_mask(params, var), val - !!open); } else if (hw_is_interval(var)) - changed = interval_refine_max(hw_param_interval(params, var), val, open); + changed = snd_interval_refine_max(hw_param_interval(params, var), val, open); else { assert(0); return -EINVAL; @@ -477,16 +477,16 @@ int _snd_pcm_hw_param_minmax(snd_pcm_hw_params_t *params, } } if (hw_is_mask(var)) { - mask_t *mask = hw_param_mask(params, var); + snd_mask_t *mask = hw_param_mask(params, var); if (max == 0 && openmax) { - mask_none(mask); + snd_mask_none(mask); changed = -EINVAL; } else { - c1 = mask_refine_min(mask, min + !!openmin); + c1 = snd_mask_refine_min(mask, min + !!openmin); if (c1 < 0) changed = c1; else { - c2 = mask_refine_max(mask, max - !!openmax); + c2 = snd_mask_refine_max(mask, max - !!openmax); if (c2 < 0) changed = c2; else @@ -495,12 +495,12 @@ int _snd_pcm_hw_param_minmax(snd_pcm_hw_params_t *params, } } else if (hw_is_interval(var)) { - interval_t *i = hw_param_interval(params, var); - c1 = interval_refine_min(i, min, openmin); + snd_interval_t *i = hw_param_interval(params, var); + c1 = snd_interval_refine_min(i, min, openmin); if (c1 < 0) changed = c1; else { - c2 = interval_refine_max(i, max, openmax); + c2 = snd_interval_refine_max(i, max, openmax); if (c2 < 0) changed = c2; else @@ -562,26 +562,26 @@ int _snd_pcm_hw_param_set(snd_pcm_hw_params_t *params, { int changed; if (hw_is_mask(var)) { - mask_t *m = hw_param_mask(params, var); + snd_mask_t *m = hw_param_mask(params, var); if (val == 0 && dir < 0) { changed = -EINVAL; - mask_none(m); + snd_mask_none(m); } else { if (dir > 0) val++; else if (dir < 0) val--; - changed = mask_refine_set(hw_param_mask(params, var), val); + changed = snd_mask_refine_set(hw_param_mask(params, var), val); } } else if (hw_is_interval(var)) { - interval_t *i = hw_param_interval(params, var); + snd_interval_t *i = hw_param_interval(params, var); if (val == 0 && dir < 0) { changed = -EINVAL; - interval_none(i); + snd_interval_none(i); } else if (dir == 0) - changed = interval_refine_set(i, val); + changed = snd_interval_refine_set(i, val); else { - interval_t t; + snd_interval_t t; t.openmin = 1; t.openmax = 1; t.empty = 0; @@ -593,7 +593,7 @@ int _snd_pcm_hw_param_set(snd_pcm_hw_params_t *params, t.min = val; t.max = val+1; } - changed = interval_refine(i, &t); + changed = snd_interval_refine(i, &t); } } else { assert(0); @@ -637,11 +637,11 @@ int snd_pcm_hw_param_set_try(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, } int _snd_pcm_hw_param_mask(snd_pcm_hw_params_t *params, - snd_pcm_hw_param_t var, const mask_t *val) + snd_pcm_hw_param_t var, const snd_mask_t *val) { int changed; assert(hw_is_mask(var)); - changed = mask_refine(hw_param_mask(params, var), val); + changed = snd_mask_refine(hw_param_mask(params, var), val); if (changed) { params->cmask |= 1 << var; params->rmask |= 1 << var; @@ -657,7 +657,7 @@ int _snd_pcm_hw_param_mask(snd_pcm_hw_params_t *params, if the configuration space is empty */ int snd_pcm_hw_param_mask(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, - snd_pcm_hw_param_t var, const mask_t *val) + snd_pcm_hw_param_t var, const snd_mask_t *val) { int changed = _snd_pcm_hw_param_mask(params, var, val); if (changed < 0) @@ -670,8 +670,8 @@ int snd_pcm_hw_param_mask(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, return 0; } -int snd_pcm_hw_param_mask_try(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, - snd_pcm_hw_param_t var, const mask_t *val) +int snd_pcm_hw_param_snd_mask_try(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, + snd_pcm_hw_param_t var, const snd_mask_t *val) { snd_pcm_hw_params_t save; int err; @@ -859,9 +859,9 @@ int snd_pcm_hw_param_empty(const snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var) { if (hw_is_mask(var)) - return mask_empty(hw_param_mask_c(params, var)); + return snd_mask_empty(hw_param_mask_c(params, var)); if (hw_is_interval(var)) - return interval_empty(hw_param_interval_c(params, var)); + return snd_interval_empty(hw_param_interval_c(params, var)); assert(0); return -EINVAL; } @@ -871,10 +871,10 @@ int snd_pcm_hw_param_always_eq(const snd_pcm_hw_params_t *params, const snd_pcm_hw_params_t *params1) { if (hw_is_mask(var)) - return mask_always_eq(hw_param_mask_c(params, var), + return snd_mask_always_eq(hw_param_mask_c(params, var), hw_param_mask_c(params1, var)); if (hw_is_interval(var)) - return interval_always_eq(hw_param_interval_c(params, var), + return snd_interval_always_eq(hw_param_interval_c(params, var), hw_param_interval_c(params1, var)); assert(0); return -EINVAL; @@ -885,10 +885,10 @@ int snd_pcm_hw_param_never_eq(const snd_pcm_hw_params_t *params, const snd_pcm_hw_params_t *params1) { if (hw_is_mask(var)) - return mask_never_eq(hw_param_mask_c(params, var), + return snd_mask_never_eq(hw_param_mask_c(params, var), hw_param_mask_c(params1, var)); if (hw_is_interval(var)) - return interval_never_eq(hw_param_interval_c(params, var), + return snd_interval_never_eq(hw_param_interval_c(params, var), hw_param_interval_c(params1, var)); assert(0); return -EINVAL; @@ -1026,12 +1026,12 @@ int snd_pcm_hw_param_test(const snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var, unsigned int val) { if (hw_is_mask(var)) { - const mask_t *mask = hw_param_mask_c(params, var); - return mask_test(mask, val); + const snd_mask_t *mask = hw_param_mask_c(params, var); + return snd_mask_test(mask, val); } if (hw_is_interval(var)) { - const interval_t *i = hw_param_interval_c(params, var); - return interval_test(i, val); + const snd_interval_t *i = hw_param_interval_c(params, var); + return snd_interval_test(i, val); } assert(0); return -EINVAL; @@ -1041,12 +1041,12 @@ unsigned int snd_pcm_hw_param_count(const snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var) { if (hw_is_mask(var)) { - const mask_t *mask = hw_param_mask_c(params, var); - return mask_count(mask); + const snd_mask_t *mask = hw_param_mask_c(params, var); + return snd_mask_count(mask); } if (hw_is_interval(var)) { - const interval_t *i = hw_param_interval_c(params, var); - return interval_max(i) - interval_min(i) + 1; + const snd_interval_t *i = hw_param_interval_c(params, var); + return snd_interval_max(i) - snd_interval_min(i) + 1; } assert(0); return 0; @@ -1058,13 +1058,13 @@ int _snd_pcm_hw_param_refine(snd_pcm_hw_params_t *params, { int changed = 0; if (hw_is_mask(var)) { - mask_t *d = hw_param_mask(params, var); - const mask_t *s = hw_param_mask_c(src, var); - changed = mask_refine(d, s); + snd_mask_t *d = hw_param_mask(params, var); + const snd_mask_t *s = hw_param_mask_c(src, var); + changed = snd_mask_refine(d, s); } else if (hw_is_interval(var)) { - interval_t *d = hw_param_interval(params, var); - const interval_t *s = hw_param_interval_c(src, var); - changed = interval_refine(d, s); + snd_interval_t *d = hw_param_interval(params, var); + const snd_interval_t *s = hw_param_interval_c(src, var); + changed = snd_interval_refine(d, s); } else assert(0); if (changed) { @@ -1078,16 +1078,16 @@ void _snd_pcm_hw_param_copy(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var, const snd_pcm_hw_params_t *src) { if (hw_is_mask(var)) { - mask_t *d = hw_param_mask(params, var); - const mask_t *s = hw_param_mask_c(src, var); - mask_copy(d, s); + snd_mask_t *d = hw_param_mask(params, var); + const snd_mask_t *s = hw_param_mask_c(src, var); + snd_mask_copy(d, s); params->cmask |= 1 << var; params->rmask |= 1 << var; } if (hw_is_interval(var)) { - interval_t *d = hw_param_interval(params, var); - const interval_t *s = hw_param_interval_c(src, var); - interval_copy(d, s); + snd_interval_t *d = hw_param_interval(params, var); + const snd_interval_t *s = hw_param_interval_c(src, var); + snd_interval_copy(d, s); params->cmask |= 1 << var; params->rmask |= 1 << var; } @@ -1103,10 +1103,10 @@ void snd_pcm_hw_param_dump(const snd_pcm_hw_params_t *params, [SND_PCM_HW_PARAM_SUBFORMAT] = snd_pcm_subformat_name, }; if (hw_is_mask(var)) { - const mask_t *mask = hw_param_mask_c(params, var); - if (mask_empty(mask)) + const snd_mask_t *mask = hw_param_mask_c(params, var); + if (snd_mask_empty(mask)) snd_output_puts(out, " NONE"); - else if (mask_full(mask)) + else if (snd_mask_full(mask)) snd_output_puts(out, " ALL"); else { unsigned int k; @@ -1114,8 +1114,8 @@ void snd_pcm_hw_param_dump(const snd_pcm_hw_params_t *params, assert(var < sizeof(funcs) / sizeof(funcs[0])); f = funcs[var]; assert(f); - for (k = 0; k <= MASK_MAX; ++k) { - if (mask_test(mask, k)) { + for (k = 0; k <= SND_MASK_MAX; ++k) { + if (snd_mask_test(mask, k)) { const char *s = f(k); if (s) { snd_output_putc(out, ' '); @@ -1127,7 +1127,7 @@ void snd_pcm_hw_param_dump(const snd_pcm_hw_params_t *params, return; } if (hw_is_interval(var)) { - interval_print(hw_param_interval_c(params, var), out); + snd_interval_print(hw_param_interval_c(params, var), out); return; } assert(0); @@ -1513,39 +1513,39 @@ struct _snd_pcm_hw_rule { int snd_pcm_hw_rule_mul(snd_pcm_hw_params_t *params, snd_pcm_hw_rule_t *rule) { - interval_t t; - interval_mul(hw_param_interval_c(params, rule->deps[0]), + snd_interval_t t; + snd_interval_mul(hw_param_interval_c(params, rule->deps[0]), hw_param_interval_c(params, rule->deps[1]), &t); - return interval_refine(hw_param_interval(params, rule->var), &t); + return snd_interval_refine(hw_param_interval(params, rule->var), &t); } int snd_pcm_hw_rule_div(snd_pcm_hw_params_t *params, snd_pcm_hw_rule_t *rule) { - interval_t t; - interval_div(hw_param_interval_c(params, rule->deps[0]), + snd_interval_t t; + snd_interval_div(hw_param_interval_c(params, rule->deps[0]), hw_param_interval_c(params, rule->deps[1]), &t); - return interval_refine(hw_param_interval(params, rule->var), &t); + return snd_interval_refine(hw_param_interval(params, rule->var), &t); } int snd_pcm_hw_rule_muldivk(snd_pcm_hw_params_t *params, snd_pcm_hw_rule_t *rule) { - interval_t t; - interval_muldivk(hw_param_interval_c(params, rule->deps[0]), + snd_interval_t t; + snd_interval_muldivk(hw_param_interval_c(params, rule->deps[0]), hw_param_interval_c(params, rule->deps[1]), (unsigned long) rule->private, &t); - return interval_refine(hw_param_interval(params, rule->var), &t); + return snd_interval_refine(hw_param_interval(params, rule->var), &t); } int snd_pcm_hw_rule_mulkdiv(snd_pcm_hw_params_t *params, snd_pcm_hw_rule_t *rule) { - interval_t t; - interval_mulkdiv(hw_param_interval_c(params, rule->deps[0]), + snd_interval_t t; + snd_interval_mulkdiv(hw_param_interval_c(params, rule->deps[0]), (unsigned long) rule->private, hw_param_interval_c(params, rule->deps[1]), &t); - return interval_refine(hw_param_interval(params, rule->var), &t); + return snd_interval_refine(hw_param_interval(params, rule->var), &t); } int snd_pcm_hw_rule_format(snd_pcm_hw_params_t *params, @@ -1553,18 +1553,18 @@ int snd_pcm_hw_rule_format(snd_pcm_hw_params_t *params, { int changed = 0; unsigned int k; - mask_t *mask = hw_param_mask(params, rule->var); - interval_t *i = hw_param_interval(params, rule->deps[0]); + snd_mask_t *mask = hw_param_mask(params, rule->var); + snd_interval_t *i = hw_param_interval(params, rule->deps[0]); for (k = 0; k <= SND_PCM_FORMAT_LAST; ++k) { int bits; - if (!mask_test(mask, k)) + if (!snd_mask_test(mask, k)) continue; bits = snd_pcm_format_physical_width(k); if (bits < 0) continue; - if (!interval_test(i, bits)) { - mask_reset(mask, k); - if (mask_empty(mask)) + if (!snd_interval_test(i, bits)) { + snd_mask_reset(mask, k); + if (snd_mask_empty(mask)) return -EINVAL; changed = 1; } @@ -1578,14 +1578,14 @@ int snd_pcm_hw_rule_sample_bits(snd_pcm_hw_params_t *params, { unsigned int min, max; unsigned int k; - interval_t *i = hw_param_interval(params, rule->var); - mask_t *mask = hw_param_mask(params, rule->deps[0]); + snd_interval_t *i = hw_param_interval(params, rule->var); + snd_mask_t *mask = hw_param_mask(params, rule->deps[0]); int c, changed = 0; min = UINT_MAX; max = 0; for (k = 0; k <= SND_PCM_FORMAT_LAST; ++k) { int bits; - if (!mask_test(mask, k)) + if (!snd_mask_test(mask, k)) continue; bits = snd_pcm_format_physical_width(k); if (bits < 0) @@ -1595,12 +1595,12 @@ int snd_pcm_hw_rule_sample_bits(snd_pcm_hw_params_t *params, if (max < (unsigned)bits) max = bits; } - c = interval_refine_min(i, min, 0); + c = snd_interval_refine_min(i, min, 0); if (c < 0) return c; if (c) changed = 1; - c = interval_refine_max(i, max, 0); + c = snd_interval_refine_max(i, max, 0); if (c < 0) return c; if (c) @@ -1752,7 +1752,7 @@ static snd_pcm_hw_rule_t refine_rules[] = { #define RULES (sizeof(refine_rules) / sizeof(refine_rules[0])) -static mask_t refine_masks[SND_PCM_HW_PARAM_LAST_MASK - SND_PCM_HW_PARAM_FIRST_MASK + 1] = { +static snd_mask_t refine_masks[SND_PCM_HW_PARAM_LAST_MASK - SND_PCM_HW_PARAM_FIRST_MASK + 1] = { [SND_PCM_HW_PARAM_ACCESS - SND_PCM_HW_PARAM_FIRST_MASK] = { bits: (1 << (SND_PCM_ACCESS_LAST + 1)) - 1, }, @@ -1764,7 +1764,7 @@ static mask_t refine_masks[SND_PCM_HW_PARAM_LAST_MASK - SND_PCM_HW_PARAM_FIRST_M }, }; -static interval_t refine_intervals[SND_PCM_HW_PARAM_LAST_INTERVAL - SND_PCM_HW_PARAM_FIRST_INTERVAL + 1] = { +static snd_interval_t refine_intervals[SND_PCM_HW_PARAM_LAST_INTERVAL - SND_PCM_HW_PARAM_FIRST_INTERVAL + 1] = { [SND_PCM_HW_PARAM_SAMPLE_BITS - SND_PCM_HW_PARAM_FIRST_INTERVAL] = { min: 1, max: UINT_MAX, openmin: 0, openmax: 0, integer: 1, empty: 0, @@ -1820,7 +1820,7 @@ static interval_t refine_intervals[SND_PCM_HW_PARAM_LAST_INTERVAL - SND_PCM_HW_P int snd_pcm_hw_refine_soft(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *params) { unsigned int k; - interval_t *i; + snd_interval_t *i; unsigned int rstamps[RULES]; unsigned int vstamps[SND_PCM_HW_PARAM_LAST + 1]; unsigned int stamp = 2; @@ -1833,7 +1833,7 @@ int snd_pcm_hw_refine_soft(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t for (k = SND_PCM_HW_PARAM_FIRST_MASK; k <= SND_PCM_HW_PARAM_LAST_MASK; k++) { if (!(params->rmask & (1 << k))) continue; - changed = mask_refine(hw_param_mask(params, k), + changed = snd_mask_refine(hw_param_mask(params, k), &refine_masks[k - SND_PCM_HW_PARAM_FIRST_MASK]); if (changed) params->cmask |= 1 << k; @@ -1844,7 +1844,7 @@ int snd_pcm_hw_refine_soft(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t for (k = SND_PCM_HW_PARAM_FIRST_INTERVAL; k <= SND_PCM_HW_PARAM_LAST_INTERVAL; k++) { if (!(params->rmask & (1 << k))) continue; - changed = interval_refine(hw_param_interval(params, k), + changed = snd_interval_refine(hw_param_interval(params, k), &refine_intervals[k - SND_PCM_HW_PARAM_FIRST_INTERVAL]); if (changed) params->cmask |= 1 << k; @@ -1902,14 +1902,14 @@ int snd_pcm_hw_refine_soft(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t } while (again); if (!params->msbits) { i = hw_param_interval(params, SND_PCM_HW_PARAM_SAMPLE_BITS); - if (interval_single(i)) - params->msbits = interval_value(i); + if (snd_interval_single(i)) + params->msbits = snd_interval_value(i); } if (!params->rate_den) { i = hw_param_interval(params, SND_PCM_HW_PARAM_RATE); - if (interval_single(i)) { - params->rate_num = interval_value(i); + if (snd_interval_single(i)) { + params->rate_num = snd_interval_value(i); params->rate_den = 1; } } diff --git a/src/pcm/pcm_plug.c b/src/pcm/pcm_plug.c index 968e19f6..b1caccec 100644 --- a/src/pcm/pcm_plug.c +++ b/src/pcm/pcm_plug.c @@ -120,14 +120,14 @@ static unsigned int nonlinear_preferred_formats[] = { SND_PCM_FORMAT_IMA_ADPCM, }; -static int snd_pcm_plug_slave_format(int format, const mask_t *format_mask) +static int snd_pcm_plug_slave_format(int format, const snd_mask_t *format_mask) { int w, u, e, wid, w1, dw; - mask_t *lin = alloca(mask_sizeof()); - if (mask_test(format_mask, format)) + snd_mask_t *lin = alloca(snd_mask_sizeof()); + if (snd_mask_test(format_mask, format)) return format; - mask_load(lin, SND_PCM_FMTBIT_LINEAR); - if (!mask_test(lin, format)) { + snd_mask_load(lin, SND_PCM_FMTBIT_LINEAR); + if (!snd_mask_test(lin, format)) { unsigned int i; switch (format) { case SND_PCM_FORMAT_MU_LAW: @@ -135,7 +135,7 @@ static int snd_pcm_plug_slave_format(int format, const mask_t *format_mask) case SND_PCM_FORMAT_IMA_ADPCM: for (i = 0; i < sizeof(linear_preferred_formats) / sizeof(linear_preferred_formats[0]); ++i) { unsigned int f = linear_preferred_formats[i]; - if (mask_test(format_mask, f)) + if (snd_mask_test(format_mask, f)) return f; } /* Fall through */ @@ -144,12 +144,12 @@ static int snd_pcm_plug_slave_format(int format, const mask_t *format_mask) } } - mask_intersect(lin, format_mask); - if (mask_empty(lin)) { + snd_mask_intersect(lin, format_mask); + if (snd_mask_empty(lin)) { unsigned int i; for (i = 0; i < sizeof(nonlinear_preferred_formats) / sizeof(nonlinear_preferred_formats[0]); ++i) { unsigned int f = nonlinear_preferred_formats[i]; - if (mask_test(format_mask, f)) + if (snd_mask_test(format_mask, f)) return f; } return -EINVAL; @@ -166,7 +166,7 @@ static int snd_pcm_plug_slave_format(int format, const mask_t *format_mask) for (sgn = 0; sgn < 2; ++sgn) { int f; f = snd_pcm_build_linear_format(w1, u1, e1); - if (f >= 0 && mask_test(format_mask, f)) + if (f >= 0 && snd_mask_test(format_mask, f)) return f; u1 = !u1; } @@ -419,12 +419,12 @@ static int snd_pcm_plug_hw_refine_schange(snd_pcm_t *pcm, snd_pcm_hw_params_t *p snd_pcm_t *slave = plug->req_slave; unsigned int links = (SND_PCM_HW_PARBIT_PERIOD_TIME | SND_PCM_HW_PARBIT_TICK_TIME); - const mask_t *format_mask, *sformat_mask; - mask_t *sfmt_mask = alloca(mask_sizeof()); + const snd_mask_t *format_mask, *sformat_mask; + snd_mask_t *sfmt_mask = alloca(snd_mask_sizeof()); int err; unsigned int format; - interval_t t, buffer_size; - const interval_t *srate, *crate; + snd_interval_t t, buffer_size; + const snd_interval_t *srate, *crate; snd_pcm_hw_param_refine_near(slave, sparams, SND_PCM_HW_PARAM_RATE, params); snd_pcm_hw_param_refine_near(slave, sparams, SND_PCM_HW_PARAM_CHANNELS, @@ -433,19 +433,19 @@ static int snd_pcm_plug_hw_refine_schange(snd_pcm_t *pcm, snd_pcm_hw_params_t *p SND_PCM_HW_PARAM_FORMAT); sformat_mask = snd_pcm_hw_param_value_mask(sparams, SND_PCM_HW_PARAM_FORMAT); - mask_none(sfmt_mask); + snd_mask_none(sfmt_mask); for (format = 0; format <= SND_PCM_FORMAT_LAST; format++) { int f; - if (!mask_test(format_mask, format)) + if (!snd_mask_test(format_mask, format)) continue; - if (mask_test(sformat_mask, format)) + if (snd_mask_test(sformat_mask, format)) f = format; else { f = snd_pcm_plug_slave_format(format, sformat_mask); if (f < 0) continue; } - mask_set(sfmt_mask, f); + snd_mask_set(sfmt_mask, f); } err = snd_pcm_hw_param_mask(slave, sparams, @@ -456,16 +456,16 @@ static int snd_pcm_plug_hw_refine_schange(snd_pcm_t *pcm, snd_pcm_hw_params_t *p snd_pcm_hw_param_never_eq(params, SND_PCM_HW_PARAM_CHANNELS, sparams) || snd_pcm_hw_param_never_eq(params, SND_PCM_HW_PARAM_RATE, sparams) || snd_pcm_hw_param_never_eq(params, SND_PCM_HW_PARAM_ACCESS, sparams)) { - mask_t *access_mask = alloca(mask_sizeof()); - mask_load(access_mask, SND_PCM_ACCBIT_MMAP); + snd_mask_t *access_mask = alloca(snd_mask_sizeof()); + snd_mask_load(access_mask, SND_PCM_ACCBIT_MMAP); _snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS, access_mask); } - interval_copy(&buffer_size, snd_pcm_hw_param_value_interval(params, SND_PCM_HW_PARAM_BUFFER_SIZE)); - interval_unfloor(&buffer_size); + snd_interval_copy(&buffer_size, snd_pcm_hw_param_value_interval(params, SND_PCM_HW_PARAM_BUFFER_SIZE)); + snd_interval_unfloor(&buffer_size); crate = snd_pcm_hw_param_value_interval(params, SND_PCM_HW_PARAM_RATE); srate = snd_pcm_hw_param_value_interval(sparams, SND_PCM_HW_PARAM_RATE); - interval_muldiv(&buffer_size, srate, crate, &t); + snd_interval_muldiv(&buffer_size, srate, crate, &t); err = _snd_pcm_hw_param_refine_interval(sparams, SND_PCM_HW_PARAM_BUFFER_SIZE, &t); if (err < 0) return err; @@ -481,32 +481,32 @@ static int snd_pcm_plug_hw_refine_cchange(snd_pcm_t *pcm ATTRIBUTE_UNUSED, { unsigned int links = (SND_PCM_HW_PARBIT_PERIOD_TIME | SND_PCM_HW_PARBIT_TICK_TIME); - const mask_t *format_mask, *sformat_mask; - mask_t *fmt_mask = alloca(mask_sizeof()); + const snd_mask_t *format_mask, *sformat_mask; + snd_mask_t *fmt_mask = alloca(snd_mask_sizeof()); int err; unsigned int format; - interval_t t; - const interval_t *sbuffer_size; - const interval_t *srate, *crate; + snd_interval_t t; + const snd_interval_t *sbuffer_size; + const snd_interval_t *srate, *crate; unsigned int rate_min, srate_min; int rate_mindir, srate_mindir; format_mask = snd_pcm_hw_param_value_mask(params, SND_PCM_HW_PARAM_FORMAT); sformat_mask = snd_pcm_hw_param_value_mask(sparams, SND_PCM_HW_PARAM_FORMAT); - mask_none(fmt_mask); + snd_mask_none(fmt_mask); for (format = 0; format <= SND_PCM_FORMAT_LAST; format++) { int f; - if (!mask_test(format_mask, format)) + if (!snd_mask_test(format_mask, format)) continue; - if (mask_test(sformat_mask, format)) + if (snd_mask_test(sformat_mask, format)) f = format; else { f = snd_pcm_plug_slave_format(format, sformat_mask); if (f < 0) continue; } - mask_set(fmt_mask, format); + snd_mask_set(fmt_mask, format); } err = _snd_pcm_hw_param_mask(params, @@ -526,8 +526,8 @@ static int snd_pcm_plug_hw_refine_cchange(snd_pcm_t *pcm ATTRIBUTE_UNUSED, sbuffer_size = snd_pcm_hw_param_value_interval(sparams, SND_PCM_HW_PARAM_BUFFER_SIZE); crate = snd_pcm_hw_param_value_interval(params, SND_PCM_HW_PARAM_RATE); srate = snd_pcm_hw_param_value_interval(sparams, SND_PCM_HW_PARAM_RATE); - interval_muldiv(sbuffer_size, crate, srate, &t); - interval_floor(&t); + snd_interval_muldiv(sbuffer_size, crate, srate, &t); + snd_interval_floor(&t); err = _snd_pcm_hw_param_refine_interval(params, SND_PCM_HW_PARAM_BUFFER_SIZE, &t); if (err < 0) return err; diff --git a/src/pcm/pcm_rate.c b/src/pcm/pcm_rate.c index f9c70e56..a13350d6 100644 --- a/src/pcm/pcm_rate.c +++ b/src/pcm/pcm_rate.c @@ -225,10 +225,10 @@ snd_pcm_uframes_t snd_pcm_rate_shrink(const snd_pcm_channel_area_t *src_areas, static int snd_pcm_rate_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *params) { int err; - mask_t *access_mask = alloca(mask_sizeof()); - mask_t *format_mask = alloca(mask_sizeof()); - mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN); - mask_load(format_mask, SND_PCM_FMTBIT_LINEAR); + snd_mask_t *access_mask = alloca(snd_mask_sizeof()); + snd_mask_t *format_mask = alloca(snd_mask_sizeof()); + snd_mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN); + snd_mask_load(format_mask, SND_PCM_FMTBIT_LINEAR); err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS, access_mask); if (err < 0) @@ -256,8 +256,8 @@ static int snd_pcm_rate_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_ static int snd_pcm_rate_hw_refine_sprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *sparams) { snd_pcm_rate_t *rate = pcm->private; - mask_t *saccess_mask = alloca(mask_sizeof()); - mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP); + snd_mask_t *saccess_mask = alloca(snd_mask_sizeof()); + snd_mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP); _snd_pcm_hw_params_any(sparams); _snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS, saccess_mask); @@ -276,8 +276,8 @@ static int snd_pcm_rate_hw_refine_schange(snd_pcm_t *pcm, snd_pcm_hw_params_t *p snd_pcm_hw_params_t *sparams) { snd_pcm_rate_t *rate = pcm->private; - interval_t t, buffer_size; - const interval_t *srate, *crate; + snd_interval_t t, buffer_size; + const snd_interval_t *srate, *crate; int err; unsigned int links = (SND_PCM_HW_PARBIT_CHANNELS | SND_PCM_HW_PARBIT_PERIOD_TIME | @@ -287,11 +287,11 @@ static int snd_pcm_rate_hw_refine_schange(snd_pcm_t *pcm, snd_pcm_hw_params_t *p SND_PCM_HW_PARBIT_SUBFORMAT | SND_PCM_HW_PARBIT_SAMPLE_BITS | SND_PCM_HW_PARBIT_FRAME_BITS); - interval_copy(&buffer_size, snd_pcm_hw_param_value_interval(params, SND_PCM_HW_PARAM_BUFFER_SIZE)); - interval_unfloor(&buffer_size); + snd_interval_copy(&buffer_size, snd_pcm_hw_param_value_interval(params, SND_PCM_HW_PARAM_BUFFER_SIZE)); + snd_interval_unfloor(&buffer_size); crate = snd_pcm_hw_param_value_interval(params, SND_PCM_HW_PARAM_RATE); srate = snd_pcm_hw_param_value_interval(sparams, SND_PCM_HW_PARAM_RATE); - interval_muldiv(&buffer_size, srate, crate, &t); + snd_interval_muldiv(&buffer_size, srate, crate, &t); err = _snd_pcm_hw_param_refine_interval(sparams, SND_PCM_HW_PARAM_BUFFER_SIZE, &t); if (err < 0) return err; @@ -305,9 +305,9 @@ static int snd_pcm_rate_hw_refine_cchange(snd_pcm_t *pcm, snd_pcm_hw_params_t *p snd_pcm_hw_params_t *sparams) { snd_pcm_rate_t *rate = pcm->private; - interval_t t; - const interval_t *sbuffer_size; - const interval_t *srate, *crate; + snd_interval_t t; + const snd_interval_t *sbuffer_size; + const snd_interval_t *srate, *crate; int err; unsigned int links = (SND_PCM_HW_PARBIT_CHANNELS | SND_PCM_HW_PARBIT_PERIOD_TIME | @@ -320,8 +320,8 @@ static int snd_pcm_rate_hw_refine_cchange(snd_pcm_t *pcm, snd_pcm_hw_params_t *p sbuffer_size = snd_pcm_hw_param_value_interval(sparams, SND_PCM_HW_PARAM_BUFFER_SIZE); crate = snd_pcm_hw_param_value_interval(params, SND_PCM_HW_PARAM_RATE); srate = snd_pcm_hw_param_value_interval(sparams, SND_PCM_HW_PARAM_RATE); - interval_muldiv(sbuffer_size, crate, srate, &t); - interval_floor(&t); + snd_interval_muldiv(sbuffer_size, crate, srate, &t); + snd_interval_floor(&t); err = _snd_pcm_hw_param_refine_interval(params, SND_PCM_HW_PARAM_BUFFER_SIZE, &t); if (err < 0) return err; diff --git a/src/pcm/pcm_route.c b/src/pcm/pcm_route.c index 21a01d80..1a8b22e4 100644 --- a/src/pcm/pcm_route.c +++ b/src/pcm/pcm_route.c @@ -428,10 +428,10 @@ static int snd_pcm_route_close(snd_pcm_t *pcm) static int snd_pcm_route_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *params) { int err; - mask_t *access_mask = alloca(mask_sizeof()); - mask_t *format_mask = alloca(mask_sizeof()); - mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN); - mask_load(format_mask, SND_PCM_FMTBIT_LINEAR); + snd_mask_t *access_mask = alloca(snd_mask_sizeof()); + snd_mask_t *format_mask = alloca(snd_mask_sizeof()); + snd_mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN); + snd_mask_load(format_mask, SND_PCM_FMTBIT_LINEAR); err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS, access_mask); if (err < 0) @@ -454,8 +454,8 @@ static int snd_pcm_route_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd static int snd_pcm_route_hw_refine_sprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *sparams) { snd_pcm_route_t *route = pcm->private; - mask_t *saccess_mask = alloca(mask_sizeof()); - mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP); + snd_mask_t *saccess_mask = alloca(snd_mask_sizeof()); + snd_mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP); _snd_pcm_hw_params_any(sparams); _snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS, saccess_mask); diff --git a/src/pcm/pcm_share.c b/src/pcm/pcm_share.c index 194d000a..fbd87142 100644 --- a/src/pcm/pcm_share.c +++ b/src/pcm/pcm_share.c @@ -460,10 +460,10 @@ static int snd_pcm_share_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t { snd_pcm_share_t *share = pcm->private; snd_pcm_share_slave_t *slave = share->slave; - mask_t *access_mask = alloca(mask_sizeof()); + snd_mask_t *access_mask = alloca(snd_mask_sizeof()); int err; - mask_any(access_mask); - mask_reset(access_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED); + snd_mask_any(access_mask); + snd_mask_reset(access_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED); err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS, access_mask); if (err < 0) @@ -493,8 +493,8 @@ static int snd_pcm_share_hw_refine_sprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t { snd_pcm_share_t *share = pcm->private; snd_pcm_share_slave_t *slave = share->slave; - mask_t *saccess_mask = alloca(mask_sizeof()); - mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP); + snd_mask_t *saccess_mask = alloca(snd_mask_sizeof()); + snd_mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP); _snd_pcm_hw_params_any(sparams); _snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS, saccess_mask); @@ -516,13 +516,13 @@ static int snd_pcm_share_hw_refine_schange(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_ SND_PCM_HW_PARBIT_BUFFER_TIME | SND_PCM_HW_PARBIT_PERIODS | SND_PCM_HW_PARBIT_TICK_TIME); - const mask_t *access_mask = snd_pcm_hw_param_value_mask(params, SND_PCM_HW_PARAM_ACCESS); - if (!mask_test(access_mask, SND_PCM_ACCESS_RW_INTERLEAVED) && - !mask_test(access_mask, SND_PCM_ACCESS_RW_NONINTERLEAVED) && - !mask_test(access_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED)) { - mask_t *saccess_mask = alloca(mask_sizeof()); - mask_any(saccess_mask); - mask_reset(saccess_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED); + const snd_mask_t *access_mask = snd_pcm_hw_param_value_mask(params, SND_PCM_HW_PARAM_ACCESS); + if (!snd_mask_test(access_mask, SND_PCM_ACCESS_RW_INTERLEAVED) && + !snd_mask_test(access_mask, SND_PCM_ACCESS_RW_NONINTERLEAVED) && + !snd_mask_test(access_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED)) { + snd_mask_t *saccess_mask = alloca(snd_mask_sizeof()); + snd_mask_any(saccess_mask); + snd_mask_reset(saccess_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED); err = _snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS, saccess_mask); if (err < 0) @@ -547,15 +547,15 @@ static int snd_pcm_share_hw_refine_cchange(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_ SND_PCM_HW_PARBIT_BUFFER_TIME | SND_PCM_HW_PARBIT_PERIODS | SND_PCM_HW_PARBIT_TICK_TIME); - mask_t *access_mask = alloca(mask_sizeof()); - const mask_t *saccess_mask = snd_pcm_hw_param_value_mask(sparams, SND_PCM_HW_PARAM_ACCESS); - mask_any(access_mask); - mask_reset(access_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED); - if (!mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED)) - mask_reset(access_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED); - if (!mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_COMPLEX) && - !mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED)) - mask_reset(access_mask, SND_PCM_ACCESS_MMAP_COMPLEX); + snd_mask_t *access_mask = alloca(snd_mask_sizeof()); + const snd_mask_t *saccess_mask = snd_pcm_hw_param_value_mask(sparams, SND_PCM_HW_PARAM_ACCESS); + snd_mask_any(access_mask); + snd_mask_reset(access_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED); + if (!snd_mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED)) + snd_mask_reset(access_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED); + if (!snd_mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_COMPLEX) && + !snd_mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED)) + snd_mask_reset(access_mask, SND_PCM_ACCESS_MMAP_COMPLEX); err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS, access_mask); if (err < 0) diff --git a/src/pcm/pcm_shm.c b/src/pcm/pcm_shm.c index 3e21df3b..ca00418a 100644 --- a/src/pcm/pcm_shm.c +++ b/src/pcm/pcm_shm.c @@ -162,8 +162,8 @@ static int snd_pcm_shm_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_p static int snd_pcm_shm_hw_refine_sprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *sparams) { - mask_t *saccess_mask = alloca(mask_sizeof()); - mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP); + snd_mask_t *saccess_mask = alloca(snd_mask_sizeof()); + snd_mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP); _snd_pcm_hw_params_any(sparams); _snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS, saccess_mask); @@ -175,9 +175,9 @@ static int snd_pcm_shm_hw_refine_schange(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pc { int err; unsigned int links = ~SND_PCM_HW_PARBIT_ACCESS; - const mask_t *access_mask = snd_pcm_hw_param_value_mask(params, SND_PCM_HW_PARAM_ACCESS); - if (!mask_test(access_mask, SND_PCM_ACCESS_RW_INTERLEAVED) && - !mask_test(access_mask, SND_PCM_ACCESS_RW_NONINTERLEAVED)) { + const snd_mask_t *access_mask = snd_pcm_hw_param_value_mask(params, SND_PCM_HW_PARAM_ACCESS); + if (!snd_mask_test(access_mask, SND_PCM_ACCESS_RW_INTERLEAVED) && + !snd_mask_test(access_mask, SND_PCM_ACCESS_RW_NONINTERLEAVED)) { err = _snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS, access_mask); if (err < 0) @@ -194,10 +194,10 @@ static int snd_pcm_shm_hw_refine_cchange(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pc { int err; unsigned int links = ~SND_PCM_HW_PARBIT_ACCESS; - mask_t *access_mask = alloca(mask_sizeof()); - mask_copy(access_mask, snd_pcm_hw_param_value_mask(sparams, SND_PCM_HW_PARAM_ACCESS)); - mask_set(access_mask, SND_PCM_ACCESS_RW_INTERLEAVED); - mask_set(access_mask, SND_PCM_ACCESS_RW_NONINTERLEAVED); + snd_mask_t *access_mask = alloca(snd_mask_sizeof()); + snd_mask_copy(access_mask, snd_pcm_hw_param_value_mask(sparams, SND_PCM_HW_PARAM_ACCESS)); + snd_mask_set(access_mask, SND_PCM_ACCESS_RW_INTERLEAVED); + snd_mask_set(access_mask, SND_PCM_ACCESS_RW_NONINTERLEAVED); err = _snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS, access_mask); if (err < 0)