# 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
* *
****************************************************************************/
+/* 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,
#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
#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
* *
****************************************************************************/
+/* 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)
* *
****************************************************************************/
+/* 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 {
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);
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,
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);
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);
* *
****************************************************************************/
+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<<SND_RAWMIDI_STREAM_OUTPUT)
#define SND_RAWMIDI_OPEN_INPUT (1<<SND_RAWMIDI_STREAM_INPUT)
#define SND_RAWMIDI_OPEN_DUPLEX (SND_RAWMIDI_OPEN_OUTPUT|SND_RAWMIDI_OPEN_INPUT)
#define SND_RAWMIDI_APPEND 1
#define SND_RAWMIDI_NONBLOCK 2
-#ifdef __cplusplus
-extern "C" {
-#endif
-
typedef struct _snd_rawmidi snd_rawmidi_t;
typedef enum _snd_rawmidi_type {
SND_RAWMIDI_TYPE_INET,
} snd_rawmidi_type_t;
+#ifdef __cplusplus
+extern "C" {
+#endif
+
int snd_rawmidi_open(snd_rawmidi_t **handle, char *name, int streams, int mode);
int snd_rawmidi_close(snd_rawmidi_t *handle);
int snd_rawmidi_card(snd_rawmidi_t *handle);
* *
****************************************************************************/
+/* sndrv aliasing */
+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
+
+
#define SND_SEQ_OPEN_OUTPUT 1
#define SND_SEQ_OPEN_INPUT 2
#define SND_SEQ_OPEN_DUPLEX (SND_SEQ_OPEN_OUTPUT|SND_SEQ_OPEN_INPUT)
#define SND_SEQ_NONBLOCK 1
-#ifdef __cplusplus
-extern "C" {
-#endif
-
typedef enum _snd_seq_type {
SND_SEQ_TYPE_HW,
SND_SEQ_TYPE_SHM,
typedef struct _snd_seq snd_seq_t;
+#ifdef __cplusplus
+extern "C" {
+#endif
+
int snd_seq_open(snd_seq_t **handle, char *name, int streams, int mode);
int snd_seq_close(snd_seq_t *handle);
int snd_seq_poll_descriptor(snd_seq_t *handle);
* *
****************************************************************************/
+/* sndrv aliasing */
+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;
+#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
+
+typedef struct _snd_timer snd_timer_t;
+
#ifdef __cplusplus
extern "C" {
#endif
-typedef struct _snd_timer snd_timer_t;
-
int snd_timer_open(snd_timer_t **handle);
int snd_timer_close(snd_timer_t *handle);
int snd_timer_poll_descriptor(snd_timer_t *handle);
*
*/
-#define INTERVAL_C
-#define INTERVAL_INLINE
+#define SND_INTERVAL_C
+#define SND_INTERVAL_INLINE
#include <sys/types.h>
#include <limits.h>
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;
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;
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;
}
} 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;
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;
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;
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;
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;
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;
}
/* 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;
}
/* 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;
}
/* 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;
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 ? '(' : '[',
#include <stdio.h>
-#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);
*
*/
-#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;
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;
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) {
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;
}
-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 ||
*
*/
-#define MASK_C
-#define MASK_INLINE
+#define SND_MASK_C
+#define SND_MASK_INLINE
#include <sys/types.h>
#include <limits.h>
#include <assert.h>
#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
#include <sys/types.h>
#include <assert.h>
-#ifdef MASK_C
+#ifdef SND_MASK_C
#define INLINE inline
#else
#define INLINE extern inline
#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)
{
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;
}
{
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 {
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);
{
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 {
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);
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)
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);
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;
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);
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);
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);
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);
{
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");
{
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");
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)
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);
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,
{
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 {
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);
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)
{
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);
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)
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)
*/
#include "pcm_local.h"
-#define INTERVAL_INLINE
-#define MASK_INLINE
+#define SND_INTERVAL_INLINE
+#define SND_MASK_INLINE
#include "interval.h"
#include "mask.h"
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;
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;
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;
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;
/* 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));
/* 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));
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;
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 {
{
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;
{
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;
{
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;
}
}
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;
}
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;
}
}
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
}
}
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
{
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;
t.min = val;
t.max = val+1;
}
- changed = interval_refine(i, &t);
+ changed = snd_interval_refine(i, &t);
}
} else {
assert(0);
}
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;
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)
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;
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;
}
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;
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;
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;
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;
{
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) {
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;
}
[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;
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, ' ');
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);
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,
{
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;
}
{
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)
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)
#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,
},
},
};
-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,
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;
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;
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;
} 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;
}
}
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:
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 */
}
}
- 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;
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;
}
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,
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,
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;
{
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,
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;
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)
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);
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 |
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;
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 |
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;
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)
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);
{
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)
{
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);
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)
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)
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);
{
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)
{
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)
OSDN Git Service
