mirrors/alsa-lib
1
0
Fork 0
mirror of https://github.com/alsa-project/alsa-lib.git synced 2025-10-29 05:40:25 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Added snd_ prefix to mask and interval. Divided header.h wrappers

Browse source
This commit is contained in:
Abramo Bagnara 2001-01-30 16:51:26 +00:00
parent 9712a67778
commit 8712ffc6a5
28 changed files with 1122 additions and 1122 deletions
Download patch file Download diff file Expand all files Collapse all files

5
include/Makefile.am
View file

@ -3,8 +3,9 @@ sysinclude_HEADERS = asoundlib.h
# This is the order they will be concatenated into asoundlib.h!
#
header_files=header.h version.h global.h input.h output.h error.h control.h mixer.h \
pcm.h rawmidi.h timer.h hwdep.h seq.h seqmid.h seq_midi_event.h \
header_files=header.h version.h global.h input.h output.h error.h mixer.h \
pcm.h rawmidi.h timer.h hwdep.h control.h \
seq.h seqmid.h seq_midi_event.h \
conv.h instr.h conf.h footer.h
noinst_HEADERS=$(header_files) search.h list.h aserver.h local.h

109
include/control.h
View file

@ -5,6 +5,115 @@
* *
****************************************************************************/
/* sndrv aliasing */
typedef struct sndrv_aes_iec958 snd_aes_iec958_t;
typedef union sndrv_digital_audio snd_digital_audio_t;
typedef enum sndrv_card_type snd_card_type;
typedef struct sndrv_ctl_hw_info snd_ctl_hw_info_t;
typedef enum sndrv_control_type snd_control_type_t;
typedef enum sndrv_control_iface snd_control_iface_t;
typedef struct sndrv_control_id snd_control_id_t;
typedef struct sndrv_control_list snd_control_list_t;
typedef struct sndrv_control_info snd_control_info_t;
typedef struct sndrv_control snd_control_t;
typedef enum sndrv_ctl_event_type snd_ctl_event_type_t;
typedef struct sndrv_ctl_event snd_ctl_event_t;
#define SND_CARD_TYPE_GUS_CLASSIC SNDRV_CARD_TYPE_GUS_CLASSIC
#define SND_CARD_TYPE_GUS_EXTREME SNDRV_CARD_TYPE_GUS_EXTREME
#define SND_CARD_TYPE_GUS_ACE SNDRV_CARD_TYPE_GUS_ACE
#define SND_CARD_TYPE_GUS_MAX SNDRV_CARD_TYPE_GUS_MAX
#define SND_CARD_TYPE_AMD_INTERWAVE SNDRV_CARD_TYPE_AMD_INTERWAVE
#define SND_CARD_TYPE_SB_10 SNDRV_CARD_TYPE_SB_10
#define SND_CARD_TYPE_SB_20 SNDRV_CARD_TYPE_SB_20
#define SND_CARD_TYPE_SB_PRO SNDRV_CARD_TYPE_SB_PRO
#define SND_CARD_TYPE_SB_16 SNDRV_CARD_TYPE_SB_16
#define SND_CARD_TYPE_SB_AWE SNDRV_CARD_TYPE_SB_AWE
#define SND_CARD_TYPE_ESS_ES1688 SNDRV_CARD_TYPE_ESS_ES1688
#define SND_CARD_TYPE_OPL3_SA2 SNDRV_CARD_TYPE_OPL3_SA2
#define SND_CARD_TYPE_MOZART SNDRV_CARD_TYPE_MOZART
#define SND_CARD_TYPE_S3_SONICVIBES SNDRV_CARD_TYPE_S3_SONICVIBES
#define SND_CARD_TYPE_ENS1370 SNDRV_CARD_TYPE_ENS1370
#define SND_CARD_TYPE_ENS1371 SNDRV_CARD_TYPE_ENS1371
#define SND_CARD_TYPE_CS4232 SNDRV_CARD_TYPE_CS4232
#define SND_CARD_TYPE_CS4236 SNDRV_CARD_TYPE_CS4236
#define SND_CARD_TYPE_AMD_INTERWAVE_STB SNDRV_CARD_TYPE_AMD_INTERWAVE_STB
#define SND_CARD_TYPE_ESS_ES1938 SNDRV_CARD_TYPE_ESS_ES1938
#define SND_CARD_TYPE_ESS_ES18XX SNDRV_CARD_TYPE_ESS_ES18XX
#define SND_CARD_TYPE_CS4231 SNDRV_CARD_TYPE_CS4231
#define SND_CARD_TYPE_OPTI92X SNDRV_CARD_TYPE_OPTI92X
#define SND_CARD_TYPE_SERIAL SNDRV_CARD_TYPE_SERIAL
#define SND_CARD_TYPE_AD1848 SNDRV_CARD_TYPE_AD1848
#define SND_CARD_TYPE_TRID4DWAVEDX SNDRV_CARD_TYPE_TRID4DWAVEDX
#define SND_CARD_TYPE_TRID4DWAVENX SNDRV_CARD_TYPE_TRID4DWAVENX
#define SND_CARD_TYPE_SGALAXY SNDRV_CARD_TYPE_SGALAXY
#define SND_CARD_TYPE_CS46XX SNDRV_CARD_TYPE_CS46XX
#define SND_CARD_TYPE_WAVEFRONT SNDRV_CARD_TYPE_WAVEFRONT
#define SND_CARD_TYPE_TROPEZ SNDRV_CARD_TYPE_TROPEZ
#define SND_CARD_TYPE_TROPEZPLUS SNDRV_CARD_TYPE_TROPEZPLUS
#define SND_CARD_TYPE_MAUI SNDRV_CARD_TYPE_MAUI
#define SND_CARD_TYPE_CMI8330 SNDRV_CARD_TYPE_CMI8330
#define SND_CARD_TYPE_DUMMY SNDRV_CARD_TYPE_DUMMY
#define SND_CARD_TYPE_ALS100 SNDRV_CARD_TYPE_ALS100
#define SND_CARD_TYPE_SHARE SNDRV_CARD_TYPE_SHARE
#define SND_CARD_TYPE_SI_7018 SNDRV_CARD_TYPE_SI_7018
#define SND_CARD_TYPE_OPTI93X SNDRV_CARD_TYPE_OPTI93X
#define SND_CARD_TYPE_MTPAV SNDRV_CARD_TYPE_MTPAV
#define SND_CARD_TYPE_VIRMIDI SNDRV_CARD_TYPE_VIRMIDI
#define SND_CARD_TYPE_EMU10K1 SNDRV_CARD_TYPE_EMU10K1
#define SND_CARD_TYPE_HAMMERFALL SNDRV_CARD_TYPE_HAMMERFALL
#define SND_CARD_TYPE_HAMMERFALL_LIGHT SNDRV_CARD_TYPE_HAMMERFALL_LIGHT
#define SND_CARD_TYPE_ICE1712 SNDRV_CARD_TYPE_ICE1712
#define SND_CARD_TYPE_CMI8338 SNDRV_CARD_TYPE_CMI8338
#define SND_CARD_TYPE_CMI8738 SNDRV_CARD_TYPE_CMI8738
#define SND_CARD_TYPE_AD1816A SNDRV_CARD_TYPE_AD1816A
#define SND_CARD_TYPE_INTEL8X0 SNDRV_CARD_TYPE_INTEL8X0
#define SND_CARD_TYPE_ESS_ESOLDM1 SNDRV_CARD_TYPE_ESS_ESOLDM1
#define SND_CARD_TYPE_ESS_ES1968 SNDRV_CARD_TYPE_ESS_ES1968
#define SND_CARD_TYPE_ESS_ES1978 SNDRV_CARD_TYPE_ESS_ES1978
#define SND_CARD_TYPE_DIGI96 SNDRV_CARD_TYPE_DIGI96
#define SND_CARD_TYPE_VIA82C686A SNDRV_CARD_TYPE_VIA82C686A
#define SND_CARD_TYPE_FM801 SNDRV_CARD_TYPE_FM801
#define SND_CARD_TYPE_AZT2320 SNDRV_CARD_TYPE_AZT2320
#define SND_CARD_TYPE_PRODIF_PLUS SNDRV_CARD_TYPE_PRODIF_PLUS
#define SND_CARD_TYPE_YMFPCI SNDRV_CARD_TYPE_YMFPCI
#define SND_CARD_TYPE_CS4281 SNDRV_CARD_TYPE_CS4281
#define SND_CARD_TYPE_MPU401_UART SNDRV_CARD_TYPE_MPU401_UART
#define SND_CARD_TYPE_ALS4000 SNDRV_CARD_TYPE_ALS4000
#define SND_CARD_TYPE_ALLEGRO_1 SNDRV_CARD_TYPE_ALLEGRO_1
#define SND_CARD_TYPE_ALLEGRO SNDRV_CARD_TYPE_ALLEGRO
#define SND_CARD_TYPE_MAESTRO3 SNDRV_CARD_TYPE_MAESTRO3
#define SND_CARD_TYPE_AWACS SNDRV_CARD_TYPE_AWACS
#define SND_CARD_TYPE_NM256AV SNDRV_CARD_TYPE_NM256AV
#define SND_CARD_TYPE_NM256ZX SNDRV_CARD_TYPE_NM256ZX
#define SND_CARD_TYPE_VIA8233 SNDRV_CARD_TYPE_VIA8233
#define SND_CARD_TYPE_LAST SNDRV_CARD_TYPE_LAST
#define SND_CONTROL_TYPE_NONE SNDRV_CONTROL_TYPE_NONE
#define SND_CONTROL_TYPE_BOOLEAN SNDRV_CONTROL_TYPE_BOOLEAN
#define SND_CONTROL_TYPE_INTEGER SNDRV_CONTROL_TYPE_INTEGER
#define SND_CONTROL_TYPE_ENUMERATED SNDRV_CONTROL_TYPE_ENUMERATED
#define SND_CONTROL_TYPE_BYTES SNDRV_CONTROL_TYPE_BYTES
#define SND_CONTROL_TYPE_IEC958 SNDRV_CONTROL_TYPE_IEC958
#define SND_CONTROL_IFACE_CARD SNDRV_CONTROL_IFACE_CARD
#define SND_CONTROL_IFACE_HWDEP SNDRV_CONTROL_IFACE_HWDEP
#define SND_CONTROL_IFACE_MIXER SNDRV_CONTROL_IFACE_MIXER
#define SND_CONTROL_IFACE_PCM SNDRV_CONTROL_IFACE_PCM
#define SND_CONTROL_IFACE_RAWMIDI SNDRV_CONTROL_IFACE_RAWMIDI
#define SND_CONTROL_IFACE_TIMER SNDRV_CONTROL_IFACE_TIMER
#define SND_CONTROL_IFACE_SEQUENCER SNDRV_CONTROL_IFACE_SEQUENCER
#define SND_CONTROL_ACCESS_READ SNDRV_CONTROL_ACCESS_READ
#define SND_CONTROL_ACCESS_WRITE SNDRV_CONTROL_ACCESS_WRITE
#define SND_CONTROL_ACCESS_READWRITE SNDRV_CONTROL_ACCESS_READWRITE
#define SND_CONTROL_ACCESS_VOLATILE SNDRV_CONTROL_ACCESS_VOLATILE
#define SND_CONTROL_ACCESS_INACTIVE SNDRV_CONTROL_ACCESS_INACTIVE
#define SND_CONTROL_ACCESS_LOCK SNDRV_CONTROL_ACCESS_LOCK
#define SND_CONTROL_ACCESS_INDIRECT SNDRV_CONTROL_ACCESS_INDIRECT
#define SND_CTL_EVENT_REBUILD SNDRV_CTL_EVENT_REBUILD
#define SND_CTL_EVENT_VALUE SNDRV_CTL_EVENT_VALUE
#define SND_CTL_EVENT_CHANGE SNDRV_CTL_EVENT_CHANGE
#define SND_CTL_EVENT_ADD SNDRV_CTL_EVENT_ADD
#define SND_CTL_EVENT_REMOVE SNDRV_CTL_EVENT_REMOVE
typedef struct _snd_ctl snd_ctl_t;
typedef enum _snd_ctl_type { SND_CTL_TYPE_HW,

597
include/header.h
View file

@ -37,65 +37,6 @@
#define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
#endif
/* Temporary hack */
/* asound.h */
typedef struct timeval snd_timestamp_t;
typedef struct interval interval_t;
typedef enum sndrv_card_type snd_card_type;
typedef sndrv_pcm_uframes_t snd_pcm_uframes_t;
typedef sndrv_pcm_sframes_t snd_pcm_sframes_t;
typedef struct sndrv_aes_iec958 snd_aes_iec958_t;
typedef union sndrv_digital_audio snd_digital_audio_t;
typedef enum sndrv_hwdep_type snd_hwdep_type_t;
typedef struct sndrv_hwdep_info snd_hwdep_info_t;
typedef enum sndrv_pcm_class snd_pcm_class_t;
typedef enum sndrv_pcm_subclass snd_pcm_subclass_t;
typedef enum sndrv_pcm_stream snd_pcm_stream_t;
typedef enum sndrv_pcm_access snd_pcm_access_t;
typedef enum sndrv_pcm_format snd_pcm_format_t;
typedef enum sndrv_pcm_subformat snd_pcm_subformat_t;
typedef enum sndrv_pcm_state snd_pcm_state_t;
typedef union sndrv_pcm_sync_id snd_pcm_sync_id_t;
typedef struct sndrv_pcm_info snd_pcm_info_t;
typedef enum sndrv_pcm_hw_param snd_pcm_hw_param_t;
typedef struct sndrv_pcm_hw_params snd_pcm_hw_params_t;
typedef enum sndrv_pcm_start snd_pcm_start_t;
typedef enum sndrv_pcm_xrun snd_pcm_xrun_t;
typedef enum sndrv_pcm_tstamp snd_pcm_tstamp_t;
typedef struct sndrv_pcm_sw_params snd_pcm_sw_params_t;
typedef struct sndrv_pcm_hw_channel_info snd_pcm_hw_channel_info_t;
typedef struct sndrv_pcm_status snd_pcm_status_t;
typedef struct sndrv_pcm_mmap_status snd_pcm_mmap_status_t;
typedef struct sndrv_pcm_mmap_control snd_pcm_mmap_control_t;
typedef struct sndrv_xferi snd_xferi_t;
typedef struct sndrv_xfern snd_xfern_t;
typedef enum sndrv_mcmd snd_mcmd_t;
typedef enum sndrv_mctl snd_mctl_t;
typedef enum sndrv_rawmidi_stream snd_rawmidi_stream_t;
typedef struct sndrv_rawmidi_info snd_rawmidi_info_t;
typedef struct sndrv_rawmidi_params snd_rawmidi_params_t;
typedef struct sndrv_rawmidi_status snd_rawmidi_status_t;
typedef enum sndrv_timer_type snd_timer_type_t;
typedef enum sndrv_timer_slave_type snd_timer_slave_type_t;
typedef enum sndrv_timer_global snd_timer_global_t;
typedef struct sndrv_timer_id snd_timer_id_t;
typedef struct sndrv_timer_select snd_timer_select_t;
typedef struct sndrv_timer_info snd_timer_info_t;
typedef struct sndrv_timer_params snd_timer_params_t;
typedef struct sndrv_timer_status snd_timer_status_t;
typedef struct sndrv_timer_read snd_timer_read_t;
typedef struct sndrv_ctl_hw_info snd_ctl_hw_info_t;
typedef enum sndrv_control_type snd_control_type_t;
typedef enum sndrv_control_iface snd_control_iface_t;
typedef struct sndrv_control_id snd_control_id_t;
typedef struct sndrv_control_list snd_control_list_t;
typedef struct sndrv_control_info snd_control_info_t;
typedef struct sndrv_control snd_control_t;
typedef enum sndrv_ctl_event_type snd_ctl_event_type_t;
typedef struct sndrv_ctl_event snd_ctl_event_t;
typedef struct sndrv_xferv snd_xferv_t;
#ifdef SNDRV_LITTLE_ENDIAN
#define SND_LITTLE_ENDIAN SNDRV_LITTLE_ENDIAN
#endif
@ -104,541 +45,3 @@ typedef struct sndrv_xferv snd_xferv_t;
#define SND_BIG_ENDIAN SNDRV_BIG_ENDIAN
#endif
#define SND_CARD_TYPE_GUS_CLASSIC SNDRV_CARD_TYPE_GUS_CLASSIC
#define SND_CARD_TYPE_GUS_EXTREME SNDRV_CARD_TYPE_GUS_EXTREME
#define SND_CARD_TYPE_GUS_ACE SNDRV_CARD_TYPE_GUS_ACE
#define SND_CARD_TYPE_GUS_MAX SNDRV_CARD_TYPE_GUS_MAX
#define SND_CARD_TYPE_AMD_INTERWAVE SNDRV_CARD_TYPE_AMD_INTERWAVE
#define SND_CARD_TYPE_SB_10 SNDRV_CARD_TYPE_SB_10
#define SND_CARD_TYPE_SB_20 SNDRV_CARD_TYPE_SB_20
#define SND_CARD_TYPE_SB_PRO SNDRV_CARD_TYPE_SB_PRO
#define SND_CARD_TYPE_SB_16 SNDRV_CARD_TYPE_SB_16
#define SND_CARD_TYPE_SB_AWE SNDRV_CARD_TYPE_SB_AWE
#define SND_CARD_TYPE_ESS_ES1688 SNDRV_CARD_TYPE_ESS_ES1688
#define SND_CARD_TYPE_OPL3_SA2 SNDRV_CARD_TYPE_OPL3_SA2
#define SND_CARD_TYPE_MOZART SNDRV_CARD_TYPE_MOZART
#define SND_CARD_TYPE_S3_SONICVIBES SNDRV_CARD_TYPE_S3_SONICVIBES
#define SND_CARD_TYPE_ENS1370 SNDRV_CARD_TYPE_ENS1370
#define SND_CARD_TYPE_ENS1371 SNDRV_CARD_TYPE_ENS1371
#define SND_CARD_TYPE_CS4232 SNDRV_CARD_TYPE_CS4232
#define SND_CARD_TYPE_CS4236 SNDRV_CARD_TYPE_CS4236
#define SND_CARD_TYPE_AMD_INTERWAVE_STB SNDRV_CARD_TYPE_AMD_INTERWAVE_STB
#define SND_CARD_TYPE_ESS_ES1938 SNDRV_CARD_TYPE_ESS_ES1938
#define SND_CARD_TYPE_ESS_ES18XX SNDRV_CARD_TYPE_ESS_ES18XX
#define SND_CARD_TYPE_CS4231 SNDRV_CARD_TYPE_CS4231
#define SND_CARD_TYPE_OPTI92X SNDRV_CARD_TYPE_OPTI92X
#define SND_CARD_TYPE_SERIAL SNDRV_CARD_TYPE_SERIAL
#define SND_CARD_TYPE_AD1848 SNDRV_CARD_TYPE_AD1848
#define SND_CARD_TYPE_TRID4DWAVEDX SNDRV_CARD_TYPE_TRID4DWAVEDX
#define SND_CARD_TYPE_TRID4DWAVENX SNDRV_CARD_TYPE_TRID4DWAVENX
#define SND_CARD_TYPE_SGALAXY SNDRV_CARD_TYPE_SGALAXY
#define SND_CARD_TYPE_CS46XX SNDRV_CARD_TYPE_CS46XX
#define SND_CARD_TYPE_WAVEFRONT SNDRV_CARD_TYPE_WAVEFRONT
#define SND_CARD_TYPE_TROPEZ SNDRV_CARD_TYPE_TROPEZ
#define SND_CARD_TYPE_TROPEZPLUS SNDRV_CARD_TYPE_TROPEZPLUS
#define SND_CARD_TYPE_MAUI SNDRV_CARD_TYPE_MAUI
#define SND_CARD_TYPE_CMI8330 SNDRV_CARD_TYPE_CMI8330
#define SND_CARD_TYPE_DUMMY SNDRV_CARD_TYPE_DUMMY
#define SND_CARD_TYPE_ALS100 SNDRV_CARD_TYPE_ALS100
#define SND_CARD_TYPE_SHARE SNDRV_CARD_TYPE_SHARE
#define SND_CARD_TYPE_SI_7018 SNDRV_CARD_TYPE_SI_7018
#define SND_CARD_TYPE_OPTI93X SNDRV_CARD_TYPE_OPTI93X
#define SND_CARD_TYPE_MTPAV SNDRV_CARD_TYPE_MTPAV
#define SND_CARD_TYPE_VIRMIDI SNDRV_CARD_TYPE_VIRMIDI
#define SND_CARD_TYPE_EMU10K1 SNDRV_CARD_TYPE_EMU10K1
#define SND_CARD_TYPE_HAMMERFALL SNDRV_CARD_TYPE_HAMMERFALL
#define SND_CARD_TYPE_HAMMERFALL_LIGHT SNDRV_CARD_TYPE_HAMMERFALL_LIGHT
#define SND_CARD_TYPE_ICE1712 SNDRV_CARD_TYPE_ICE1712
#define SND_CARD_TYPE_CMI8338 SNDRV_CARD_TYPE_CMI8338
#define SND_CARD_TYPE_CMI8738 SNDRV_CARD_TYPE_CMI8738
#define SND_CARD_TYPE_AD1816A SNDRV_CARD_TYPE_AD1816A
#define SND_CARD_TYPE_INTEL8X0 SNDRV_CARD_TYPE_INTEL8X0
#define SND_CARD_TYPE_ESS_ESOLDM1 SNDRV_CARD_TYPE_ESS_ESOLDM1
#define SND_CARD_TYPE_ESS_ES1968 SNDRV_CARD_TYPE_ESS_ES1968
#define SND_CARD_TYPE_ESS_ES1978 SNDRV_CARD_TYPE_ESS_ES1978
#define SND_CARD_TYPE_DIGI96 SNDRV_CARD_TYPE_DIGI96
#define SND_CARD_TYPE_VIA82C686A SNDRV_CARD_TYPE_VIA82C686A
#define SND_CARD_TYPE_FM801 SNDRV_CARD_TYPE_FM801
#define SND_CARD_TYPE_AZT2320 SNDRV_CARD_TYPE_AZT2320
#define SND_CARD_TYPE_PRODIF_PLUS SNDRV_CARD_TYPE_PRODIF_PLUS
#define SND_CARD_TYPE_YMFPCI SNDRV_CARD_TYPE_YMFPCI
#define SND_CARD_TYPE_CS4281 SNDRV_CARD_TYPE_CS4281
#define SND_CARD_TYPE_MPU401_UART SNDRV_CARD_TYPE_MPU401_UART
#define SND_CARD_TYPE_ALS4000 SNDRV_CARD_TYPE_ALS4000
#define SND_CARD_TYPE_ALLEGRO_1 SNDRV_CARD_TYPE_ALLEGRO_1
#define SND_CARD_TYPE_ALLEGRO SNDRV_CARD_TYPE_ALLEGRO
#define SND_CARD_TYPE_MAESTRO3 SNDRV_CARD_TYPE_MAESTRO3
#define SND_CARD_TYPE_AWACS SNDRV_CARD_TYPE_AWACS
#define SND_CARD_TYPE_NM256AV SNDRV_CARD_TYPE_NM256AV
#define SND_CARD_TYPE_NM256ZX SNDRV_CARD_TYPE_NM256ZX
#define SND_CARD_TYPE_VIA8233 SNDRV_CARD_TYPE_VIA8233
#define SND_CARD_TYPE_LAST SNDRV_CARD_TYPE_LAST
#define SND_HWDEP_TYPE_OPL2 SNDRV_HWDEP_TYPE_OPL2
#define SND_HWDEP_TYPE_OPL3 SNDRV_HWDEP_TYPE_OPL3
#define SND_HWDEP_TYPE_OPL4 SNDRV_HWDEP_TYPE_OPL4
#define SND_HWDEP_TYPE_SB16CSP SNDRV_HWDEP_TYPE_SB16CSP
#define SND_HWDEP_TYPE_EMU10K1 SNDRV_HWDEP_TYPE_EMU10K1
#define SND_HWDEP_TYPE_YSS225 SNDRV_HWDEP_TYPE_YSS225
#define SND_HWDEP_TYPE_ICS2115 SNDRV_HWDEP_TYPE_ICS2115
#define SND_HWDEP_TYPE_LAST SNDRV_HWDEP_TYPE_LAST
#define SND_PCM_CLASS_GENERIC SNDRV_PCM_CLASS_GENERIC
#define SND_PCM_CLASS_MULTI SNDRV_PCM_CLASS_MULTI
#define SND_PCM_CLASS_MODEM SNDRV_PCM_CLASS_MODEM
#define SND_PCM_CLASS_DIGITIZER SNDRV_PCM_CLASS_DIGITIZER
#define SND_PCM_SUBCLASS_GENERIC_MIX SNDRV_PCM_SUBCLASS_GENERIC_MIX
#define SND_PCM_SUBCLASS_MULTI_MIX SNDRV_PCM_SUBCLASS_MULTI_MIX
#define SND_PCM_STREAM_PLAYBACK SNDRV_PCM_STREAM_PLAYBACK
#define SND_PCM_STREAM_CAPTURE SNDRV_PCM_STREAM_CAPTURE
#define SND_PCM_STREAM_LAST SNDRV_PCM_STREAM_LAST
#define SND_PCM_ACCESS_MMAP_INTERLEAVED SNDRV_PCM_ACCESS_MMAP_INTERLEAVED
#define SND_PCM_ACCESS_MMAP_NONINTERLEAVED SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED
#define SND_PCM_ACCESS_MMAP_COMPLEX SNDRV_PCM_ACCESS_MMAP_COMPLEX
#define SND_PCM_ACCESS_RW_INTERLEAVED SNDRV_PCM_ACCESS_RW_INTERLEAVED
#define SND_PCM_ACCESS_RW_NONINTERLEAVED SNDRV_PCM_ACCESS_RW_NONINTERLEAVED
#define SND_PCM_ACCESS_LAST SNDRV_PCM_ACCESS_LAST
#define SND_PCM_FORMAT_S8 SNDRV_PCM_FORMAT_S8
#define SND_PCM_FORMAT_U8 SNDRV_PCM_FORMAT_U8
#define SND_PCM_FORMAT_S16_LE SNDRV_PCM_FORMAT_S16_LE
#define SND_PCM_FORMAT_S16_BE SNDRV_PCM_FORMAT_S16_BE
#define SND_PCM_FORMAT_U16_LE SNDRV_PCM_FORMAT_U16_LE
#define SND_PCM_FORMAT_U16_BE SNDRV_PCM_FORMAT_U16_BE
#define SND_PCM_FORMAT_S24_LE SNDRV_PCM_FORMAT_S24_LE
#define SND_PCM_FORMAT_S24_BE SNDRV_PCM_FORMAT_S24_BE
#define SND_PCM_FORMAT_U24_LE SNDRV_PCM_FORMAT_U24_LE
#define SND_PCM_FORMAT_U24_BE SNDRV_PCM_FORMAT_U24_BE
#define SND_PCM_FORMAT_S32_LE SNDRV_PCM_FORMAT_S32_LE
#define SND_PCM_FORMAT_S32_BE SNDRV_PCM_FORMAT_S32_BE
#define SND_PCM_FORMAT_U32_LE SNDRV_PCM_FORMAT_U32_LE
#define SND_PCM_FORMAT_U32_BE SNDRV_PCM_FORMAT_U32_BE
#define SND_PCM_FORMAT_FLOAT_LE SNDRV_PCM_FORMAT_FLOAT_LE
#define SND_PCM_FORMAT_FLOAT_BE SNDRV_PCM_FORMAT_FLOAT_BE
#define SND_PCM_FORMAT_FLOAT64_LE SNDRV_PCM_FORMAT_FLOAT64_LE
#define SND_PCM_FORMAT_FLOAT64_BE SNDRV_PCM_FORMAT_FLOAT64_BE
#define SND_PCM_FORMAT_IEC958_SUBFRAME_LE SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE
#define SND_PCM_FORMAT_IEC958_SUBFRAME_BE SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE
#define SND_PCM_FORMAT_MU_LAW SNDRV_PCM_FORMAT_MU_LAW
#define SND_PCM_FORMAT_A_LAW SNDRV_PCM_FORMAT_A_LAW
#define SND_PCM_FORMAT_IMA_ADPCM SNDRV_PCM_FORMAT_IMA_ADPCM
#define SND_PCM_FORMAT_MPEG SNDRV_PCM_FORMAT_MPEG
#define SND_PCM_FORMAT_GSM SNDRV_PCM_FORMAT_GSM
#define SND_PCM_FORMAT_SPECIAL SNDRV_PCM_FORMAT_SPECIAL
#define SND_PCM_FORMAT_LAST SNDRV_PCM_FORMAT_LAST
#define SND_PCM_FORMAT_S16 SNDRV_PCM_FORMAT_S16
#define SND_PCM_FORMAT_U16 SNDRV_PCM_FORMAT_U16
#define SND_PCM_FORMAT_S24 SNDRV_PCM_FORMAT_S24
#define SND_PCM_FORMAT_U24 SNDRV_PCM_FORMAT_U24
#define SND_PCM_FORMAT_S32 SNDRV_PCM_FORMAT_S32
#define SND_PCM_FORMAT_U32 SNDRV_PCM_FORMAT_U32
#define SND_PCM_FORMAT_FLOAT SNDRV_PCM_FORMAT_FLOAT
#define SND_PCM_FORMAT_FLOAT64 SNDRV_PCM_FORMAT_FLOAT64
#define SND_PCM_FORMAT_IEC958_SUBFRAME SNDRV_PCM_FORMAT_IEC958_SUBFRAME
#define SND_PCM_FORMAT_S16 SNDRV_PCM_FORMAT_S16
#define SND_PCM_FORMAT_U16 SNDRV_PCM_FORMAT_U16
#define SND_PCM_FORMAT_S24 SNDRV_PCM_FORMAT_S24
#define SND_PCM_FORMAT_U24 SNDRV_PCM_FORMAT_U24
#define SND_PCM_FORMAT_S32 SNDRV_PCM_FORMAT_S32
#define SND_PCM_FORMAT_U32 SNDRV_PCM_FORMAT_U32
#define SND_PCM_FORMAT_FLOAT SNDRV_PCM_FORMAT_FLOAT
#define SND_PCM_FORMAT_FLOAT64 SNDRV_PCM_FORMAT_FLOAT64
#define SND_PCM_FORMAT_IEC958_SUBFRAME SNDRV_PCM_FORMAT_IEC958_SUBFRAME
#define SND_PCM_SUBFORMAT_STD SNDRV_PCM_SUBFORMAT_STD
#define SND_PCM_SUBFORMAT_LAST SNDRV_PCM_SUBFORMAT_LAST
#define SND_PCM_INFO_MMAP SNDRV_PCM_INFO_MMAP
#define SND_PCM_INFO_MMAP_VALID SNDRV_PCM_INFO_MMAP_VALID
#define SND_PCM_INFO_DOUBLE SNDRV_PCM_INFO_DOUBLE
#define SND_PCM_INFO_BATCH SNDRV_PCM_INFO_BATCH
#define SND_PCM_INFO_INTERLEAVED SNDRV_PCM_INFO_INTERLEAVED
#define SND_PCM_INFO_NONINTERLEAVED SNDRV_PCM_INFO_NONINTERLEAVED
#define SND_PCM_INFO_COMPLEX SNDRV_PCM_INFO_COMPLEX
#define SND_PCM_INFO_BLOCK_TRANSFER SNDRV_PCM_INFO_BLOCK_TRANSFER
#define SND_PCM_INFO_OVERRANGE SNDRV_PCM_INFO_OVERRANGE
#define SND_PCM_INFO_PAUSE SNDRV_PCM_INFO_PAUSE
#define SND_PCM_INFO_HALF_DUPLEX SNDRV_PCM_INFO_HALF_DUPLEX
#define SND_PCM_INFO_JOINT_DUPLEX SNDRV_PCM_INFO_JOINT_DUPLEX
#define SND_PCM_INFO_SYNC_START SNDRV_PCM_INFO_SYNC_START
#define SND_PCM_STATE_OPEN SNDRV_PCM_STATE_OPEN
#define SND_PCM_STATE_SETUP SNDRV_PCM_STATE_SETUP
#define SND_PCM_STATE_PREPARED SNDRV_PCM_STATE_PREPARED
#define SND_PCM_STATE_RUNNING SNDRV_PCM_STATE_RUNNING
#define SND_PCM_STATE_XRUN SNDRV_PCM_STATE_XRUN
#define SND_PCM_STATE_DRAINING SNDRV_PCM_STATE_DRAINING
#define SND_PCM_STATE_PAUSED SNDRV_PCM_STATE_PAUSED
#define SND_PCM_STATE_LAST SNDRV_PCM_STATE_LAST
#define SND_PCM_MMAP_OFFSET_DATA SNDRV_PCM_MMAP_OFFSET_DATA
#define SND_PCM_MMAP_OFFSET_STATUS SNDRV_PCM_MMAP_OFFSET_STATUS
#define SND_PCM_MMAP_OFFSET_CONTROL SNDRV_PCM_MMAP_OFFSET_CONTROL
#define SND_PCM_HW_PARAM_ACCESS SNDRV_PCM_HW_PARAM_ACCESS
#define SND_PCM_HW_PARAM_FIRST_MASK SNDRV_PCM_HW_PARAM_FIRST_MASK
#define SND_PCM_HW_PARAM_FORMAT SNDRV_PCM_HW_PARAM_FORMAT
#define SND_PCM_HW_PARAM_SUBFORMAT SNDRV_PCM_HW_PARAM_SUBFORMAT
#define SND_PCM_HW_PARAM_LAST_MASK SNDRV_PCM_HW_PARAM_LAST_MASK
#define SND_PCM_HW_PARAM_SAMPLE_BITS SNDRV_PCM_HW_PARAM_SAMPLE_BITS
#define SND_PCM_HW_PARAM_FIRST_INTERVAL SNDRV_PCM_HW_PARAM_FIRST_INTERVAL
#define SND_PCM_HW_PARAM_FRAME_BITS SNDRV_PCM_HW_PARAM_FRAME_BITS
#define SND_PCM_HW_PARAM_CHANNELS SNDRV_PCM_HW_PARAM_CHANNELS
#define SND_PCM_HW_PARAM_RATE SNDRV_PCM_HW_PARAM_RATE
#define SND_PCM_HW_PARAM_PERIOD_TIME SNDRV_PCM_HW_PARAM_PERIOD_TIME
#define SND_PCM_HW_PARAM_PERIOD_SIZE SNDRV_PCM_HW_PARAM_PERIOD_SIZE
#define SND_PCM_HW_PARAM_PERIOD_BYTES SNDRV_PCM_HW_PARAM_PERIOD_BYTES
#define SND_PCM_HW_PARAM_PERIODS SNDRV_PCM_HW_PARAM_PERIODS
#define SND_PCM_HW_PARAM_BUFFER_TIME SNDRV_PCM_HW_PARAM_BUFFER_TIME
#define SND_PCM_HW_PARAM_BUFFER_SIZE SNDRV_PCM_HW_PARAM_BUFFER_SIZE
#define SND_PCM_HW_PARAM_BUFFER_BYTES SNDRV_PCM_HW_PARAM_BUFFER_BYTES
#define SND_PCM_HW_PARAM_TICK_TIME SNDRV_PCM_HW_PARAM_TICK_TIME
#define SND_PCM_HW_PARAM_LAST_INTERVAL SNDRV_PCM_HW_PARAM_LAST_INTERVAL
#define SND_PCM_HW_PARAM_LAST SNDRV_PCM_HW_PARAM_LAST
#define SND_PCM_HW_PARAMS_RUNTIME SNDRV_PCM_HW_PARAMS_RUNTIME
#define SND_PCM_HW_PARAM_LAST_MASK SNDRV_PCM_HW_PARAM_LAST_MASK
#define SND_PCM_HW_PARAM_FIRST_MASK SNDRV_PCM_HW_PARAM_FIRST_MASK
#define SND_PCM_HW_PARAM_LAST_INTERVAL SNDRV_PCM_HW_PARAM_LAST_INTERVAL
#define SND_PCM_HW_PARAM_FIRST_INTERVAL SNDRV_PCM_HW_PARAM_FIRST_INTERVAL
#define SND_PCM_START_DATA SNDRV_PCM_START_DATA
#define SND_PCM_START_EXPLICIT SNDRV_PCM_START_EXPLICIT
#define SND_PCM_START_LAST SNDRV_PCM_START_LAST
#define SND_PCM_XRUN_NONE SNDRV_PCM_XRUN_NONE
#define SND_PCM_XRUN_STOP SNDRV_PCM_XRUN_STOP
#define SND_PCM_XRUN_LAST SNDRV_PCM_XRUN_LAST
#define SND_PCM_TSTAMP_NONE SNDRV_PCM_TSTAMP_NONE
#define SND_PCM_TSTAMP_MMAP SNDRV_PCM_TSTAMP_MMAP
#define SND_PCM_TSTAMP_LAST SNDRV_PCM_TSTAMP_LAST
#define SND_PCM_STATE_XXXX SNDRV_PCM_STATE_XXXX
#define SND_MIDI_CHANNELS SNDRV_MIDI_CHANNELS
#define SND_MIDI_GM_DRUM_CHANNEL SNDRV_MIDI_GM_DRUM_CHANNEL
#define SND_RAWMIDI_STREAM_OUTPUT SNDRV_RAWMIDI_STREAM_OUTPUT
#define SND_RAWMIDI_STREAM_INPUT SNDRV_RAWMIDI_STREAM_INPUT
#define SND_RAWMIDI_INFO_OUTPUT SNDRV_RAWMIDI_INFO_OUTPUT
#define SND_RAWMIDI_INFO_INPUT SNDRV_RAWMIDI_INFO_INPUT
#define SND_RAWMIDI_INFO_DUPLEX SNDRV_RAWMIDI_INFO_DUPLEX
#define SND_RAWMIDI_INFO_XXXX SNDRV_RAWMIDI_INFO_XXXX
#define SND_RAWMIDI_PARBIT_STREAM SNDRV_RAWMIDI_PARBIT_STREAM
#define SND_RAWMIDI_PARBIT_BUFFER_SIZE SNDRV_RAWMIDI_PARBIT_BUFFER_SIZE
#define SND_RAWMIDI_PARBIT_AVAIL_MIN SNDRV_RAWMIDI_PARBIT_AVAIL_MIN
#define SND_TIMER_TYPE_NONE SNDRV_TIMER_TYPE_NONE
#define SND_TIMER_TYPE_SLAVE SNDRV_TIMER_TYPE_SLAVE
#define SND_TIMER_TYPE_GLOBAL SNDRV_TIMER_TYPE_GLOBAL
#define SND_TIMER_TYPE_CARD SNDRV_TIMER_TYPE_CARD
#define SND_TIMER_TYPE_PCM SNDRV_TIMER_TYPE_PCM
#define SND_TIMER_STYPE_NONE SNDRV_TIMER_STYPE_NONE
#define SND_TIMER_STYPE_APPLICATION SNDRV_TIMER_STYPE_APPLICATION
#define SND_TIMER_STYPE_SEQUENCER SNDRV_TIMER_STYPE_SEQUENCER
#define SND_TIMER_STYPE_OSS_SEQUENCER SNDRV_TIMER_STYPE_OSS_SEQUENCER
#define SND_TIMER_GLOBAL_SYSTEM SNDRV_TIMER_GLOBAL_SYSTEM
#define SND_TIMER_GLOBAL_RTC SNDRV_TIMER_GLOBAL_RTC
#define SND_TIMER_FLG_SLAVE SNDRV_TIMER_FLG_SLAVE
#define SND_TIMER_PARBIT_FLAGS SNDRV_TIMER_PARBIT_FLAGS
#define SND_TIMER_PARBIT_TICKS SNDRV_TIMER_PARBIT_TICKS
#define SND_TIMER_PARBIT_QUEUE_SIZE SNDRV_TIMER_PARBIT_QUEUE_SIZE
#define SND_TIMER_PSFLG_AUTO SNDRV_TIMER_PSFLG_AUTO
#define SND_CONTROL_TYPE_NONE SNDRV_CONTROL_TYPE_NONE
#define SND_CONTROL_TYPE_BOOLEAN SNDRV_CONTROL_TYPE_BOOLEAN
#define SND_CONTROL_TYPE_INTEGER SNDRV_CONTROL_TYPE_INTEGER
#define SND_CONTROL_TYPE_ENUMERATED SNDRV_CONTROL_TYPE_ENUMERATED
#define SND_CONTROL_TYPE_BYTES SNDRV_CONTROL_TYPE_BYTES
#define SND_CONTROL_TYPE_IEC958 SNDRV_CONTROL_TYPE_IEC958
#define SND_CONTROL_IFACE_CARD SNDRV_CONTROL_IFACE_CARD
#define SND_CONTROL_IFACE_HWDEP SNDRV_CONTROL_IFACE_HWDEP
#define SND_CONTROL_IFACE_MIXER SNDRV_CONTROL_IFACE_MIXER
#define SND_CONTROL_IFACE_PCM SNDRV_CONTROL_IFACE_PCM
#define SND_CONTROL_IFACE_RAWMIDI SNDRV_CONTROL_IFACE_RAWMIDI
#define SND_CONTROL_IFACE_TIMER SNDRV_CONTROL_IFACE_TIMER
#define SND_CONTROL_IFACE_SEQUENCER SNDRV_CONTROL_IFACE_SEQUENCER
#define SND_CONTROL_ACCESS_READ SNDRV_CONTROL_ACCESS_READ
#define SND_CONTROL_ACCESS_WRITE SNDRV_CONTROL_ACCESS_WRITE
#define SND_CONTROL_ACCESS_READWRITE SNDRV_CONTROL_ACCESS_READWRITE
#define SND_CONTROL_ACCESS_VOLATILE SNDRV_CONTROL_ACCESS_VOLATILE
#define SND_CONTROL_ACCESS_INACTIVE SNDRV_CONTROL_ACCESS_INACTIVE
#define SND_CONTROL_ACCESS_LOCK SNDRV_CONTROL_ACCESS_LOCK
#define SND_CONTROL_ACCESS_INDIRECT SNDRV_CONTROL_ACCESS_INDIRECT
#define SND_CTL_EVENT_REBUILD SNDRV_CTL_EVENT_REBUILD
#define SND_CTL_EVENT_VALUE SNDRV_CTL_EVENT_VALUE
#define SND_CTL_EVENT_CHANGE SNDRV_CTL_EVENT_CHANGE
#define SND_CTL_EVENT_ADD SNDRV_CTL_EVENT_ADD
#define SND_CTL_EVENT_REMOVE SNDRV_CTL_EVENT_REMOVE
/* asequencer.h */
typedef sndrv_seq_tick_time_t snd_seq_tick_time_t;
typedef sndrv_seq_position_t snd_seq_position_t;
typedef sndrv_seq_frequency_t snd_seq_frequency_t;
typedef sndrv_seq_instr_cluster_t snd_seq_instr_cluster_t;
typedef enum sndrv_seq_client_type snd_seq_client_type_t;
typedef enum sndrv_seq_stop_mode snd_seq_stop_mode_t;
typedef struct sndrv_seq_port_info snd_seq_port_info_t;
typedef struct sndrv_seq_port_subscribe snd_seq_port_subscribe_t;
typedef struct sndrv_seq_event snd_seq_event_t;
typedef struct sndrv_seq_addr snd_seq_addr_t;
typedef struct sndrv_seq_ev_volume snd_seq_ev_volume_t;
typedef struct sndrv_seq_ev_loop snd_seq_ev_loop_t;
typedef struct sndrv_seq_remove_events snd_seq_remove_events_t;
typedef struct sndrv_seq_query_subs snd_seq_query_subs_t;
typedef struct sndrv_seq_real_time snd_seq_real_time_t;
typedef struct sndrv_seq_system_info snd_seq_system_info_t;
typedef struct sndrv_seq_client_info snd_seq_client_info_t;
typedef struct sndrv_seq_queue_info snd_seq_queue_info_t;
typedef struct sndrv_seq_queue_status snd_seq_queue_status_t;
typedef struct sndrv_seq_queue_tempo snd_seq_queue_tempo_t;
typedef struct sndrv_seq_queue_owner snd_seq_queue_owner_t;
typedef struct sndrv_seq_queue_timer snd_seq_queue_timer_t;
typedef struct sndrv_seq_queue_client snd_seq_queue_client_t;
typedef struct sndrv_seq_client_pool snd_seq_client_pool_t;
typedef struct sndrv_seq_instr snd_seq_instr_t;
typedef struct sndrv_seq_instr_data snd_seq_instr_data_t;
typedef struct sndrv_seq_instr_free snd_seq_instr_free_t;
typedef struct sndrv_seq_instr_put snd_seq_instr_put_t;
typedef struct sndrv_seq_instr_get snd_seq_instr_get_t;
typedef union sndrv_seq_timestamp snd_seq_timestamp_t;
#define snd_seq_event_bounce_ext_data sndrv_seq_event_bounce_ext_data
#define snd_seq_ev_is_result_type sndrv_seq_ev_is_result_type
#define snd_seq_ev_is_channel_type sndrv_seq_ev_is_channel_type
#define snd_seq_ev_is_note_type sndrv_seq_ev_is_note_type
#define snd_seq_ev_is_control_type sndrv_seq_ev_is_control_type
#define snd_seq_ev_is_queue_type sndrv_seq_ev_is_queue_type
#define snd_seq_ev_is_message_type sndrv_seq_ev_is_message_type
#define snd_seq_ev_is_sample_type sndrv_seq_ev_is_sample_type
#define snd_seq_ev_is_user_type sndrv_seq_ev_is_user_type
#define snd_seq_ev_is_fixed_type sndrv_seq_ev_is_fixed_type
#define snd_seq_ev_is_instr_type sndrv_seq_ev_is_instr_type
#define snd_seq_ev_is_variable_type sndrv_seq_ev_is_variable_type
#define snd_seq_ev_is_varipc_type sndrv_seq_ev_is_varipc_type
#define snd_seq_ev_is_reserved sndrv_seq_ev_is_reserved
#define snd_seq_ev_is_direct sndrv_seq_ev_is_direct
#define snd_seq_ev_is_prior sndrv_seq_ev_is_prior
#define snd_seq_ev_length_type sndrv_seq_ev_length_type
#define snd_seq_ev_is_fixed sndrv_seq_ev_is_fixed
#define snd_seq_ev_is_variable sndrv_seq_ev_is_variable
#define snd_seq_ev_is_varusr sndrv_seq_ev_is_varusr
#define snd_seq_ev_is_varipc sndrv_seq_ev_is_varipc
#define snd_seq_ev_timestamp_type sndrv_seq_ev_timestamp_type
#define snd_seq_ev_is_tick sndrv_seq_ev_is_tick
#define snd_seq_ev_is_real sndrv_seq_ev_is_real
#define snd_seq_ev_timemode_type sndrv_seq_ev_timemode_type
#define snd_seq_ev_is_abstime sndrv_seq_ev_is_abstime
#define snd_seq_ev_is_reltime sndrv_seq_ev_is_reltime
#define snd_seq_queue_sync_port sndrv_seq_queue_sync_port
#define snd_seq_queue_owner sndrv_seq_queue_owner
#ifdef SNDRV_SEQ_SYNC_SUPPORT
#define SND_SEQ_SYNC_SUPPORT SNDRV_SEQ_SYNC_SUPPORT
#endif
#define SND_SEQ_EVENT_SYSTEM SNDRV_SEQ_EVENT_SYSTEM
#define SND_SEQ_EVENT_RESULT SNDRV_SEQ_EVENT_RESULT
#define SND_SEQ_EVENT_NOTE SNDRV_SEQ_EVENT_NOTE
#define SND_SEQ_EVENT_NOTEON SNDRV_SEQ_EVENT_NOTEON
#define SND_SEQ_EVENT_NOTEOFF SNDRV_SEQ_EVENT_NOTEOFF
#define SND_SEQ_EVENT_KEYPRESS SNDRV_SEQ_EVENT_KEYPRESS
#define SND_SEQ_EVENT_CONTROLLER SNDRV_SEQ_EVENT_CONTROLLER
#define SND_SEQ_EVENT_PGMCHANGE SNDRV_SEQ_EVENT_PGMCHANGE
#define SND_SEQ_EVENT_CHANPRESS SNDRV_SEQ_EVENT_CHANPRESS
#define SND_SEQ_EVENT_PITCHBEND SNDRV_SEQ_EVENT_PITCHBEND
#define SND_SEQ_EVENT_CONTROL14 SNDRV_SEQ_EVENT_CONTROL14
#define SND_SEQ_EVENT_NONREGPARAM SNDRV_SEQ_EVENT_NONREGPARAM
#define SND_SEQ_EVENT_REGPARAM SNDRV_SEQ_EVENT_REGPARAM
#define SND_SEQ_EVENT_SONGPOS SNDRV_SEQ_EVENT_SONGPOS
#define SND_SEQ_EVENT_SONGSEL SNDRV_SEQ_EVENT_SONGSEL
#define SND_SEQ_EVENT_QFRAME SNDRV_SEQ_EVENT_QFRAME
#define SND_SEQ_EVENT_TIMESIGN SNDRV_SEQ_EVENT_TIMESIGN
#define SND_SEQ_EVENT_KEYSIGN SNDRV_SEQ_EVENT_KEYSIGN
#define SND_SEQ_EVENT_START SNDRV_SEQ_EVENT_START
#define SND_SEQ_EVENT_CONTINUE SNDRV_SEQ_EVENT_CONTINUE
#define SND_SEQ_EVENT_STOP SNDRV_SEQ_EVENT_STOP
#define SND_SEQ_EVENT_SETPOS_TICK SNDRV_SEQ_EVENT_SETPOS_TICK
#define SND_SEQ_EVENT_SETPOS_TIME SNDRV_SEQ_EVENT_SETPOS_TIME
#define SND_SEQ_EVENT_TEMPO SNDRV_SEQ_EVENT_TEMPO
#define SND_SEQ_EVENT_CLOCK SNDRV_SEQ_EVENT_CLOCK
#define SND_SEQ_EVENT_TICK SNDRV_SEQ_EVENT_TICK
#define SND_SEQ_EVENT_SYNC SNDRV_SEQ_EVENT_SYNC
#define SND_SEQ_EVENT_SYNC_POS SNDRV_SEQ_EVENT_SYNC_POS
#define SND_SEQ_EVENT_TUNE_REQUEST SNDRV_SEQ_EVENT_TUNE_REQUEST
#define SND_SEQ_EVENT_RESET SNDRV_SEQ_EVENT_RESET
#define SND_SEQ_EVENT_SENSING SNDRV_SEQ_EVENT_SENSING
#define SND_SEQ_EVENT_ECHO SNDRV_SEQ_EVENT_ECHO
#define SND_SEQ_EVENT_OSS SNDRV_SEQ_EVENT_OSS
#define SND_SEQ_EVENT_CLIENT_START SNDRV_SEQ_EVENT_CLIENT_START
#define SND_SEQ_EVENT_CLIENT_EXIT SNDRV_SEQ_EVENT_CLIENT_EXIT
#define SND_SEQ_EVENT_CLIENT_CHANGE SNDRV_SEQ_EVENT_CLIENT_CHANGE
#define SND_SEQ_EVENT_PORT_START SNDRV_SEQ_EVENT_PORT_START
#define SND_SEQ_EVENT_PORT_EXIT SNDRV_SEQ_EVENT_PORT_EXIT
#define SND_SEQ_EVENT_PORT_CHANGE SNDRV_SEQ_EVENT_PORT_CHANGE
#define SND_SEQ_EVENT_PORT_SUBSCRIBED SNDRV_SEQ_EVENT_PORT_SUBSCRIBED
#define SND_SEQ_EVENT_PORT_USED SNDRV_SEQ_EVENT_PORT_USED
#define SND_SEQ_EVENT_PORT_UNSUBSCRIBED SNDRV_SEQ_EVENT_PORT_UNSUBSCRIBED
#define SND_SEQ_EVENT_PORT_UNUSED SNDRV_SEQ_EVENT_PORT_UNUSED
#define SND_SEQ_EVENT_SAMPLE SNDRV_SEQ_EVENT_SAMPLE
#define SND_SEQ_EVENT_SAMPLE_CLUSTER SNDRV_SEQ_EVENT_SAMPLE_CLUSTER
#define SND_SEQ_EVENT_SAMPLE_START SNDRV_SEQ_EVENT_SAMPLE_START
#define SND_SEQ_EVENT_SAMPLE_STOP SNDRV_SEQ_EVENT_SAMPLE_STOP
#define SND_SEQ_EVENT_SAMPLE_FREQ SNDRV_SEQ_EVENT_SAMPLE_FREQ
#define SND_SEQ_EVENT_SAMPLE_VOLUME SNDRV_SEQ_EVENT_SAMPLE_VOLUME
#define SND_SEQ_EVENT_SAMPLE_LOOP SNDRV_SEQ_EVENT_SAMPLE_LOOP
#define SND_SEQ_EVENT_SAMPLE_POSITION SNDRV_SEQ_EVENT_SAMPLE_POSITION
#define SND_SEQ_EVENT_SAMPLE_PRIVATE1 SNDRV_SEQ_EVENT_SAMPLE_PRIVATE1
#define SND_SEQ_EVENT_USR0 SNDRV_SEQ_EVENT_USR0
#define SND_SEQ_EVENT_USR1 SNDRV_SEQ_EVENT_USR1
#define SND_SEQ_EVENT_USR2 SNDRV_SEQ_EVENT_USR2
#define SND_SEQ_EVENT_USR3 SNDRV_SEQ_EVENT_USR3
#define SND_SEQ_EVENT_USR4 SNDRV_SEQ_EVENT_USR4
#define SND_SEQ_EVENT_USR5 SNDRV_SEQ_EVENT_USR5
#define SND_SEQ_EVENT_USR6 SNDRV_SEQ_EVENT_USR6
#define SND_SEQ_EVENT_USR7 SNDRV_SEQ_EVENT_USR7
#define SND_SEQ_EVENT_USR8 SNDRV_SEQ_EVENT_USR8
#define SND_SEQ_EVENT_USR9 SNDRV_SEQ_EVENT_USR9
#define SND_SEQ_EVENT_INSTR_BEGIN SNDRV_SEQ_EVENT_INSTR_BEGIN
#define SND_SEQ_EVENT_INSTR_END SNDRV_SEQ_EVENT_INSTR_END
#define SND_SEQ_EVENT_INSTR_INFO SNDRV_SEQ_EVENT_INSTR_INFO
#define SND_SEQ_EVENT_INSTR_INFO_RESULT SNDRV_SEQ_EVENT_INSTR_INFO_RESULT
#define SND_SEQ_EVENT_INSTR_FINFO SNDRV_SEQ_EVENT_INSTR_FINFO
#define SND_SEQ_EVENT_INSTR_FINFO_RESULT SNDRV_SEQ_EVENT_INSTR_FINFO_RESULT
#define SND_SEQ_EVENT_INSTR_RESET SNDRV_SEQ_EVENT_INSTR_RESET
#define SND_SEQ_EVENT_INSTR_STATUS SNDRV_SEQ_EVENT_INSTR_STATUS
#define SND_SEQ_EVENT_INSTR_STATUS_RESULT SNDRV_SEQ_EVENT_INSTR_STATUS_RESULT
#define SND_SEQ_EVENT_INSTR_PUT SNDRV_SEQ_EVENT_INSTR_PUT
#define SND_SEQ_EVENT_INSTR_GET SNDRV_SEQ_EVENT_INSTR_GET
#define SND_SEQ_EVENT_INSTR_GET_RESULT SNDRV_SEQ_EVENT_INSTR_GET_RESULT
#define SND_SEQ_EVENT_INSTR_FREE SNDRV_SEQ_EVENT_INSTR_FREE
#define SND_SEQ_EVENT_INSTR_LIST SNDRV_SEQ_EVENT_INSTR_LIST
#define SND_SEQ_EVENT_INSTR_LIST_RESULT SNDRV_SEQ_EVENT_INSTR_LIST_RESULT
#define SND_SEQ_EVENT_INSTR_CLUSTER SNDRV_SEQ_EVENT_INSTR_CLUSTER
#define SND_SEQ_EVENT_INSTR_CLUSTER_GET SNDRV_SEQ_EVENT_INSTR_CLUSTER_GET
#define SND_SEQ_EVENT_INSTR_CLUSTER_RESULT SNDRV_SEQ_EVENT_INSTR_CLUSTER_RESULT
#define SND_SEQ_EVENT_INSTR_CHANGE SNDRV_SEQ_EVENT_INSTR_CHANGE
#define SND_SEQ_EVENT_LENGTH_VARIABLE SNDRV_SEQ_EVENT_LENGTH_VARIABLE
#define SND_SEQ_EVENT_SYSEX SNDRV_SEQ_EVENT_SYSEX
#define SND_SEQ_EVENT_BOUNCE SNDRV_SEQ_EVENT_BOUNCE
#define SND_SEQ_EVENT_USR_VAR0 SNDRV_SEQ_EVENT_USR_VAR0
#define SND_SEQ_EVENT_USR_VAR1 SNDRV_SEQ_EVENT_USR_VAR1
#define SND_SEQ_EVENT_USR_VAR2 SNDRV_SEQ_EVENT_USR_VAR2
#define SND_SEQ_EVENT_USR_VAR3 SNDRV_SEQ_EVENT_USR_VAR3
#define SND_SEQ_EVENT_USR_VAR4 SNDRV_SEQ_EVENT_USR_VAR4
#define SND_SEQ_EVENT_LENGTH_VARIPC SNDRV_SEQ_EVENT_LENGTH_VARIPC
#define SND_SEQ_EVENT_IPCSHM SNDRV_SEQ_EVENT_IPCSHM
#define SND_SEQ_EVENT_USR_VARIPC0 SNDRV_SEQ_EVENT_USR_VARIPC0
#define SND_SEQ_EVENT_USR_VARIPC1 SNDRV_SEQ_EVENT_USR_VARIPC1
#define SND_SEQ_EVENT_USR_VARIPC2 SNDRV_SEQ_EVENT_USR_VARIPC2
#define SND_SEQ_EVENT_USR_VARIPC3 SNDRV_SEQ_EVENT_USR_VARIPC3
#define SND_SEQ_EVENT_USR_VARIPC4 SNDRV_SEQ_EVENT_USR_VARIPC4
#define SND_SEQ_EVENT_KERNEL_ERROR SNDRV_SEQ_EVENT_KERNEL_ERROR
#define SND_SEQ_EVENT_KERNEL_QUOTE SNDRV_SEQ_EVENT_KERNEL_QUOTE
#define SND_SEQ_EVENT_NONE SNDRV_SEQ_EVENT_NONE
#define SND_SEQ_ADDRESS_UNKNOWN SNDRV_SEQ_ADDRESS_UNKNOWN
#define SND_SEQ_ADDRESS_SUBSCRIBERS SNDRV_SEQ_ADDRESS_SUBSCRIBERS
#define SND_SEQ_ADDRESS_BROADCAST SNDRV_SEQ_ADDRESS_BROADCAST
#define SND_SEQ_QUEUE_DIRECT SNDRV_SEQ_QUEUE_DIRECT
#define SND_SEQ_TIME_STAMP_TICK SNDRV_SEQ_TIME_STAMP_TICK
#define SND_SEQ_TIME_STAMP_REAL SNDRV_SEQ_TIME_STAMP_REAL
#define SND_SEQ_TIME_STAMP_MASK SNDRV_SEQ_TIME_STAMP_MASK
#define SND_SEQ_TIME_MODE_ABS SNDRV_SEQ_TIME_MODE_ABS
#define SND_SEQ_TIME_MODE_REL SNDRV_SEQ_TIME_MODE_REL
#define SND_SEQ_TIME_MODE_MASK SNDRV_SEQ_TIME_MODE_MASK
#define SND_SEQ_EVENT_LENGTH_FIXED SNDRV_SEQ_EVENT_LENGTH_FIXED
#define SND_SEQ_EVENT_LENGTH_VARIABLE SNDRV_SEQ_EVENT_LENGTH_VARIABLE
#define SND_SEQ_EVENT_LENGTH_VARUSR SNDRV_SEQ_EVENT_LENGTH_VARUSR
#define SND_SEQ_EVENT_LENGTH_VARIPC SNDRV_SEQ_EVENT_LENGTH_VARIPC
#define SND_SEQ_EVENT_LENGTH_MASK SNDRV_SEQ_EVENT_LENGTH_MASK
#define SND_SEQ_PRIORITY_NORMAL SNDRV_SEQ_PRIORITY_NORMAL
#define SND_SEQ_PRIORITY_HIGH SNDRV_SEQ_PRIORITY_HIGH
#define SND_SEQ_PRIORITY_MASK SNDRV_SEQ_PRIORITY_MASK
#define SND_SEQ_EVENT_NOTE SNDRV_SEQ_EVENT_NOTE
#define SND_SEQ_EVENT_NOTE SNDRV_SEQ_EVENT_NOTE
#define SND_SEQ_QUEUE_DIRECT SNDRV_SEQ_QUEUE_DIRECT
#define SND_SEQ_PRIORITY_MASK SNDRV_SEQ_PRIORITY_MASK
#define SND_SEQ_EVENT_LENGTH_MASK SNDRV_SEQ_EVENT_LENGTH_MASK
#define SND_SEQ_EVENT_LENGTH_FIXED SNDRV_SEQ_EVENT_LENGTH_FIXED
#define SND_SEQ_EVENT_LENGTH_VARIABLE SNDRV_SEQ_EVENT_LENGTH_VARIABLE
#define SND_SEQ_EVENT_LENGTH_VARUSR SNDRV_SEQ_EVENT_LENGTH_VARUSR
#define SND_SEQ_EVENT_LENGTH_VARIPC SNDRV_SEQ_EVENT_LENGTH_VARIPC
#define SND_SEQ_TIME_STAMP_MASK SNDRV_SEQ_TIME_STAMP_MASK
#define SND_SEQ_TIME_STAMP_TICK SNDRV_SEQ_TIME_STAMP_TICK
#define SND_SEQ_TIME_STAMP_REAL SNDRV_SEQ_TIME_STAMP_REAL
#define SND_SEQ_TIME_MODE_MASK SNDRV_SEQ_TIME_MODE_MASK
#define SND_SEQ_TIME_MODE_ABS SNDRV_SEQ_TIME_MODE_ABS
#define SND_SEQ_TIME_MODE_REL SNDRV_SEQ_TIME_MODE_REL
#define SND_SEQ_CLIENT_SYSTEM SNDRV_SEQ_CLIENT_SYSTEM
#define SND_SEQ_CLIENT_DUMMY SNDRV_SEQ_CLIENT_DUMMY
#define SND_SEQ_CLIENT_OSS SNDRV_SEQ_CLIENT_OSS
#define SND_SEQ_FILTER_BROADCAST SNDRV_SEQ_FILTER_BROADCAST
#define SND_SEQ_FILTER_MULTICAST SNDRV_SEQ_FILTER_MULTICAST
#define SND_SEQ_FILTER_BOUNCE SNDRV_SEQ_FILTER_BOUNCE
#define SND_SEQ_FILTER_USE_EVENT SNDRV_SEQ_FILTER_USE_EVENT
#define SND_SEQ_REMOVE_DEST SNDRV_SEQ_REMOVE_DEST
#define SND_SEQ_REMOVE_DEST_CHANNEL SNDRV_SEQ_REMOVE_DEST_CHANNEL
#define SND_SEQ_REMOVE_TIME_BEFORE SNDRV_SEQ_REMOVE_TIME_BEFORE
#define SND_SEQ_REMOVE_TIME_AFTER SNDRV_SEQ_REMOVE_TIME_AFTER
#define SND_SEQ_REMOVE_EVENT_TYPE SNDRV_SEQ_REMOVE_EVENT_TYPE
#define SND_SEQ_REMOVE_IGNORE_OFF SNDRV_SEQ_REMOVE_IGNORE_OFF
#define SND_SEQ_REMOVE_TAG_MATCH SNDRV_SEQ_REMOVE_TAG_MATCH
#define SND_SEQ_PORT_SYSTEM_TIMER SNDRV_SEQ_PORT_SYSTEM_TIMER
#define SND_SEQ_PORT_SYSTEM_ANNOUNCE SNDRV_SEQ_PORT_SYSTEM_ANNOUNCE
#define SND_SEQ_PORT_CAP_READ SNDRV_SEQ_PORT_CAP_READ
#define SND_SEQ_PORT_CAP_WRITE SNDRV_SEQ_PORT_CAP_WRITE
#define SND_SEQ_PORT_CAP_SYNC_READ SNDRV_SEQ_PORT_CAP_SYNC_READ
#define SND_SEQ_PORT_CAP_SYNC_WRITE SNDRV_SEQ_PORT_CAP_SYNC_WRITE
#define SND_SEQ_PORT_CAP_DUPLEX SNDRV_SEQ_PORT_CAP_DUPLEX
#define SND_SEQ_PORT_CAP_SUBS_READ SNDRV_SEQ_PORT_CAP_SUBS_READ
#define SND_SEQ_PORT_CAP_SUBS_WRITE SNDRV_SEQ_PORT_CAP_SUBS_WRITE
#define SND_SEQ_PORT_CAP_NO_EXPORT SNDRV_SEQ_PORT_CAP_NO_EXPORT
#define SND_SEQ_PORT_TYPE_SPECIFIC SNDRV_SEQ_PORT_TYPE_SPECIFIC
#define SND_SEQ_PORT_TYPE_MIDI_GENERIC SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC
#define SND_SEQ_PORT_TYPE_MIDI_GM SNDRV_SEQ_PORT_TYPE_MIDI_GM
#define SND_SEQ_PORT_TYPE_MIDI_GS SNDRV_SEQ_PORT_TYPE_MIDI_GS
#define SND_SEQ_PORT_TYPE_MIDI_XG SNDRV_SEQ_PORT_TYPE_MIDI_XG
#define SND_SEQ_PORT_TYPE_MIDI_MT32 SNDRV_SEQ_PORT_TYPE_MIDI_MT32
#define SND_SEQ_PORT_TYPE_SYNTH SNDRV_SEQ_PORT_TYPE_SYNTH
#define SND_SEQ_PORT_TYPE_DIRECT_SAMPLE SNDRV_SEQ_PORT_TYPE_DIRECT_SAMPLE
#define SND_SEQ_PORT_TYPE_SAMPLE SNDRV_SEQ_PORT_TYPE_SAMPLE
#define SND_SEQ_PORT_TYPE_APPLICATION SNDRV_SEQ_PORT_TYPE_APPLICATION
#define SND_SEQ_GROUP_SYSTEM SNDRV_SEQ_GROUP_SYSTEM
#define SND_SEQ_GROUP_DEVICE SNDRV_SEQ_GROUP_DEVICE
#define SND_SEQ_GROUP_APPLICATION SNDRV_SEQ_GROUP_APPLICATION
#define SND_SEQ_PORT_FLG_GIVEN_PORT SNDRV_SEQ_PORT_FLG_GIVEN_PORT
#define SND_SEQ_QUEUE_FLG_SYNC SNDRV_SEQ_QUEUE_FLG_SYNC
#define SND_SEQ_QUEUE_FLG_SYNC_LOST SNDRV_SEQ_QUEUE_FLG_SYNC_LOST
#define SND_SEQ_SYNC_TICK SNDRV_SEQ_SYNC_TICK
#define SND_SEQ_SYNC_TIME SNDRV_SEQ_SYNC_TIME
#define SND_SEQ_SYNC_MODE SNDRV_SEQ_SYNC_MODE
#define SND_SEQ_SYNC_FMT_PRIVATE_CLOCK SNDRV_SEQ_SYNC_FMT_PRIVATE_CLOCK
#define SND_SEQ_SYNC_FMT_PRIVATE_TIME SNDRV_SEQ_SYNC_FMT_PRIVATE_TIME
#define SND_SEQ_SYNC_FMT_MIDI_CLOCK SNDRV_SEQ_SYNC_FMT_MIDI_CLOCK
#define SND_SEQ_SYNC_FMT_MTC SNDRV_SEQ_SYNC_FMT_MTC
#define SND_SEQ_SYNC_FMT_DTL SNDRV_SEQ_SYNC_FMT_DTL
#define SND_SEQ_SYNC_FMT_SMPTE SNDRV_SEQ_SYNC_FMT_SMPTE
#define SND_SEQ_SYNC_FMT_MIDI_TICK SNDRV_SEQ_SYNC_FMT_MIDI_TICK
#define SND_SEQ_SYNC_FPS_24 SNDRV_SEQ_SYNC_FPS_24
#define SND_SEQ_SYNC_FPS_25 SNDRV_SEQ_SYNC_FPS_25
#define SND_SEQ_SYNC_FPS_30_DP SNDRV_SEQ_SYNC_FPS_30_DP
#define SND_SEQ_SYNC_FPS_30_NDP SNDRV_SEQ_SYNC_FPS_30_NDP
#define SND_SEQ_TIMER_ALSA SNDRV_SEQ_TIMER_ALSA
#define SND_SEQ_TIMER_MIDI_CLOCK SNDRV_SEQ_TIMER_MIDI_CLOCK
#define SND_SEQ_TIMER_MIDI_TICK SNDRV_SEQ_TIMER_MIDI_TICK
#define SND_SEQ_QUERY_SUBS_READ SNDRV_SEQ_QUERY_SUBS_READ
#define SND_SEQ_QUERY_SUBS_WRITE SNDRV_SEQ_QUERY_SUBS_WRITE
#define SND_SEQ_INSTR_ATYPE_DATA SNDRV_SEQ_INSTR_ATYPE_DATA
#define SND_SEQ_INSTR_ATYPE_ALIAS SNDRV_SEQ_INSTR_ATYPE_ALIAS
#define SND_SEQ_INSTR_ID_DLS1 SNDRV_SEQ_INSTR_ID_DLS1
#define SND_SEQ_INSTR_ID_DLS2 SNDRV_SEQ_INSTR_ID_DLS2
#define SND_SEQ_INSTR_ID_SIMPLE SNDRV_SEQ_INSTR_ID_SIMPLE
#define SND_SEQ_INSTR_ID_SOUNDFONT SNDRV_SEQ_INSTR_ID_SOUNDFONT
#define SND_SEQ_INSTR_ID_GUS_PATCH SNDRV_SEQ_INSTR_ID_GUS_PATCH
#define SND_SEQ_INSTR_ID_INTERWAVE SNDRV_SEQ_INSTR_ID_INTERWAVE
#define SND_SEQ_INSTR_ID_OPL2_3 SNDRV_SEQ_INSTR_ID_OPL2_3
#define SND_SEQ_INSTR_ID_OPL4 SNDRV_SEQ_INSTR_ID_OPL4
#define SND_SEQ_INSTR_TYPE0_DLS1 SNDRV_SEQ_INSTR_TYPE0_DLS1
#define SND_SEQ_INSTR_TYPE0_DLS2 SNDRV_SEQ_INSTR_TYPE0_DLS2
#define SND_SEQ_INSTR_TYPE1_SIMPLE SNDRV_SEQ_INSTR_TYPE1_SIMPLE
#define SND_SEQ_INSTR_TYPE1_SOUNDFONT SNDRV_SEQ_INSTR_TYPE1_SOUNDFONT
#define SND_SEQ_INSTR_TYPE1_GUS_PATCH SNDRV_SEQ_INSTR_TYPE1_GUS_PATCH
#define SND_SEQ_INSTR_TYPE1_INTERWAVE SNDRV_SEQ_INSTR_TYPE1_INTERWAVE
#define SND_SEQ_INSTR_TYPE2_OPL2_3 SNDRV_SEQ_INSTR_TYPE2_OPL2_3
#define SND_SEQ_INSTR_TYPE2_OPL4 SNDRV_SEQ_INSTR_TYPE2_OPL4
#define SND_SEQ_INSTR_PUT_CMD_CREATE SNDRV_SEQ_INSTR_PUT_CMD_CREATE
#define SND_SEQ_INSTR_PUT_CMD_REPLACE SNDRV_SEQ_INSTR_PUT_CMD_REPLACE
#define SND_SEQ_INSTR_PUT_CMD_MODIFY SNDRV_SEQ_INSTR_PUT_CMD_MODIFY
#define SND_SEQ_INSTR_PUT_CMD_ADD SNDRV_SEQ_INSTR_PUT_CMD_ADD
#define SND_SEQ_INSTR_PUT_CMD_REMOVE SNDRV_SEQ_INSTR_PUT_CMD_REMOVE
#define SND_SEQ_INSTR_GET_CMD_FULL SNDRV_SEQ_INSTR_GET_CMD_FULL
#define SND_SEQ_INSTR_GET_CMD_PARTIAL SNDRV_SEQ_INSTR_GET_CMD_PARTIAL
#define SND_SEQ_INSTR_QUERY_FOLLOW_ALIAS SNDRV_SEQ_INSTR_QUERY_FOLLOW_ALIAS
#define SND_SEQ_INSTR_FREE_CMD_ALL SNDRV_SEQ_INSTR_FREE_CMD_ALL
#define SND_SEQ_INSTR_FREE_CMD_PRIVATE SNDRV_SEQ_INSTR_FREE_CMD_PRIVATE
#define SND_SEQ_INSTR_FREE_CMD_CLUSTER SNDRV_SEQ_INSTR_FREE_CMD_CLUSTER
#define SND_SEQ_INSTR_FREE_CMD_SINGLE SNDRV_SEQ_INSTR_FREE_CMD_SINGLE

12
include/hwdep.h
View file

@ -5,6 +5,18 @@
* *
****************************************************************************/
/* sndrv aliasing */
typedef enum sndrv_hwdep_type snd_hwdep_type_t;
typedef struct sndrv_hwdep_info snd_hwdep_info_t;
#define SND_HWDEP_TYPE_OPL2 SNDRV_HWDEP_TYPE_OPL2
#define SND_HWDEP_TYPE_OPL3 SNDRV_HWDEP_TYPE_OPL3
#define SND_HWDEP_TYPE_OPL4 SNDRV_HWDEP_TYPE_OPL4
#define SND_HWDEP_TYPE_SB16CSP SNDRV_HWDEP_TYPE_SB16CSP
#define SND_HWDEP_TYPE_EMU10K1 SNDRV_HWDEP_TYPE_EMU10K1
#define SND_HWDEP_TYPE_YSS225 SNDRV_HWDEP_TYPE_YSS225
#define SND_HWDEP_TYPE_ICS2115 SNDRV_HWDEP_TYPE_ICS2115
#define SND_HWDEP_TYPE_LAST SNDRV_HWDEP_TYPE_LAST
#define SND_HWDEP_OPEN_READ (O_RDONLY)
#define SND_HWDEP_OPEN_WRITE (O_WRONLY)
#define SND_HWDEP_OPEN_DUPLEX (O_RDWR)

191
include/pcm.h
View file

@ -5,13 +5,154 @@
* *
****************************************************************************/
/* sndrv aliasing */
typedef enum sndrv_pcm_class snd_pcm_class_t;
typedef enum sndrv_pcm_subclass snd_pcm_subclass_t;
typedef enum sndrv_pcm_stream snd_pcm_stream_t;
typedef enum sndrv_pcm_access snd_pcm_access_t;
typedef enum sndrv_pcm_format snd_pcm_format_t;
typedef enum sndrv_pcm_subformat snd_pcm_subformat_t;
typedef enum sndrv_pcm_state snd_pcm_state_t;
typedef enum sndrv_pcm_hw_param snd_pcm_hw_param_t;
typedef enum sndrv_pcm_start snd_pcm_start_t;
typedef enum sndrv_pcm_xrun snd_pcm_xrun_t;
typedef enum sndrv_pcm_tstamp snd_pcm_tstamp_t;
typedef sndrv_pcm_uframes_t snd_pcm_uframes_t;
typedef sndrv_pcm_sframes_t snd_pcm_sframes_t;
typedef struct timeval snd_timestamp_t;
typedef struct sndrv_interval snd_interval_t;
typedef struct sndrv_pcm_info snd_pcm_info_t;
typedef struct sndrv_pcm_hw_params snd_pcm_hw_params_t;
typedef struct sndrv_pcm_sw_params snd_pcm_sw_params_t;
typedef struct sndrv_pcm_hw_channel_info snd_pcm_hw_channel_info_t;
typedef struct sndrv_pcm_status snd_pcm_status_t;
#define SND_PCM_CLASS_GENERIC SNDRV_PCM_CLASS_GENERIC
#define SND_PCM_CLASS_MULTI SNDRV_PCM_CLASS_MULTI
#define SND_PCM_CLASS_MODEM SNDRV_PCM_CLASS_MODEM
#define SND_PCM_CLASS_DIGITIZER SNDRV_PCM_CLASS_DIGITIZER
#define SND_PCM_SUBCLASS_GENERIC_MIX SNDRV_PCM_SUBCLASS_GENERIC_MIX
#define SND_PCM_SUBCLASS_MULTI_MIX SNDRV_PCM_SUBCLASS_MULTI_MIX
#define SND_PCM_STREAM_PLAYBACK SNDRV_PCM_STREAM_PLAYBACK
#define SND_PCM_STREAM_CAPTURE SNDRV_PCM_STREAM_CAPTURE
#define SND_PCM_STREAM_LAST SNDRV_PCM_STREAM_LAST
#define SND_PCM_ACCESS_MMAP_INTERLEAVED SNDRV_PCM_ACCESS_MMAP_INTERLEAVED
#define SND_PCM_ACCESS_MMAP_NONINTERLEAVED SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED
#define SND_PCM_ACCESS_MMAP_COMPLEX SNDRV_PCM_ACCESS_MMAP_COMPLEX
#define SND_PCM_ACCESS_RW_INTERLEAVED SNDRV_PCM_ACCESS_RW_INTERLEAVED
#define SND_PCM_ACCESS_RW_NONINTERLEAVED SNDRV_PCM_ACCESS_RW_NONINTERLEAVED
#define SND_PCM_ACCESS_LAST SNDRV_PCM_ACCESS_LAST
#define SND_PCM_FORMAT_S8 SNDRV_PCM_FORMAT_S8
#define SND_PCM_FORMAT_U8 SNDRV_PCM_FORMAT_U8
#define SND_PCM_FORMAT_S16_LE SNDRV_PCM_FORMAT_S16_LE
#define SND_PCM_FORMAT_S16_BE SNDRV_PCM_FORMAT_S16_BE
#define SND_PCM_FORMAT_U16_LE SNDRV_PCM_FORMAT_U16_LE
#define SND_PCM_FORMAT_U16_BE SNDRV_PCM_FORMAT_U16_BE
#define SND_PCM_FORMAT_S24_LE SNDRV_PCM_FORMAT_S24_LE
#define SND_PCM_FORMAT_S24_BE SNDRV_PCM_FORMAT_S24_BE
#define SND_PCM_FORMAT_U24_LE SNDRV_PCM_FORMAT_U24_LE
#define SND_PCM_FORMAT_U24_BE SNDRV_PCM_FORMAT_U24_BE
#define SND_PCM_FORMAT_S32_LE SNDRV_PCM_FORMAT_S32_LE
#define SND_PCM_FORMAT_S32_BE SNDRV_PCM_FORMAT_S32_BE
#define SND_PCM_FORMAT_U32_LE SNDRV_PCM_FORMAT_U32_LE
#define SND_PCM_FORMAT_U32_BE SNDRV_PCM_FORMAT_U32_BE
#define SND_PCM_FORMAT_FLOAT_LE SNDRV_PCM_FORMAT_FLOAT_LE
#define SND_PCM_FORMAT_FLOAT_BE SNDRV_PCM_FORMAT_FLOAT_BE
#define SND_PCM_FORMAT_FLOAT64_LE SNDRV_PCM_FORMAT_FLOAT64_LE
#define SND_PCM_FORMAT_FLOAT64_BE SNDRV_PCM_FORMAT_FLOAT64_BE
#define SND_PCM_FORMAT_IEC958_SUBFRAME_LE SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE
#define SND_PCM_FORMAT_IEC958_SUBFRAME_BE SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE
#define SND_PCM_FORMAT_MU_LAW SNDRV_PCM_FORMAT_MU_LAW
#define SND_PCM_FORMAT_A_LAW SNDRV_PCM_FORMAT_A_LAW
#define SND_PCM_FORMAT_IMA_ADPCM SNDRV_PCM_FORMAT_IMA_ADPCM
#define SND_PCM_FORMAT_MPEG SNDRV_PCM_FORMAT_MPEG
#define SND_PCM_FORMAT_GSM SNDRV_PCM_FORMAT_GSM
#define SND_PCM_FORMAT_SPECIAL SNDRV_PCM_FORMAT_SPECIAL
#define SND_PCM_FORMAT_LAST SNDRV_PCM_FORMAT_LAST
#define SND_PCM_FORMAT_S16 SNDRV_PCM_FORMAT_S16
#define SND_PCM_FORMAT_U16 SNDRV_PCM_FORMAT_U16
#define SND_PCM_FORMAT_S24 SNDRV_PCM_FORMAT_S24
#define SND_PCM_FORMAT_U24 SNDRV_PCM_FORMAT_U24
#define SND_PCM_FORMAT_S32 SNDRV_PCM_FORMAT_S32
#define SND_PCM_FORMAT_U32 SNDRV_PCM_FORMAT_U32
#define SND_PCM_FORMAT_FLOAT SNDRV_PCM_FORMAT_FLOAT
#define SND_PCM_FORMAT_FLOAT64 SNDRV_PCM_FORMAT_FLOAT64
#define SND_PCM_FORMAT_IEC958_SUBFRAME SNDRV_PCM_FORMAT_IEC958_SUBFRAME
#define SND_PCM_FORMAT_S16 SNDRV_PCM_FORMAT_S16
#define SND_PCM_FORMAT_U16 SNDRV_PCM_FORMAT_U16
#define SND_PCM_FORMAT_S24 SNDRV_PCM_FORMAT_S24
#define SND_PCM_FORMAT_U24 SNDRV_PCM_FORMAT_U24
#define SND_PCM_FORMAT_S32 SNDRV_PCM_FORMAT_S32
#define SND_PCM_FORMAT_U32 SNDRV_PCM_FORMAT_U32
#define SND_PCM_FORMAT_FLOAT SNDRV_PCM_FORMAT_FLOAT
#define SND_PCM_FORMAT_FLOAT64 SNDRV_PCM_FORMAT_FLOAT64
#define SND_PCM_FORMAT_IEC958_SUBFRAME SNDRV_PCM_FORMAT_IEC958_SUBFRAME
#define SND_PCM_SUBFORMAT_STD SNDRV_PCM_SUBFORMAT_STD
#define SND_PCM_SUBFORMAT_LAST SNDRV_PCM_SUBFORMAT_LAST
#define SND_PCM_INFO_MMAP SNDRV_PCM_INFO_MMAP
#define SND_PCM_INFO_MMAP_VALID SNDRV_PCM_INFO_MMAP_VALID
#define SND_PCM_INFO_DOUBLE SNDRV_PCM_INFO_DOUBLE
#define SND_PCM_INFO_BATCH SNDRV_PCM_INFO_BATCH
#define SND_PCM_INFO_INTERLEAVED SNDRV_PCM_INFO_INTERLEAVED
#define SND_PCM_INFO_NONINTERLEAVED SNDRV_PCM_INFO_NONINTERLEAVED
#define SND_PCM_INFO_COMPLEX SNDRV_PCM_INFO_COMPLEX
#define SND_PCM_INFO_BLOCK_TRANSFER SNDRV_PCM_INFO_BLOCK_TRANSFER
#define SND_PCM_INFO_OVERRANGE SNDRV_PCM_INFO_OVERRANGE
#define SND_PCM_INFO_PAUSE SNDRV_PCM_INFO_PAUSE
#define SND_PCM_INFO_HALF_DUPLEX SNDRV_PCM_INFO_HALF_DUPLEX
#define SND_PCM_INFO_JOINT_DUPLEX SNDRV_PCM_INFO_JOINT_DUPLEX
#define SND_PCM_INFO_SYNC_START SNDRV_PCM_INFO_SYNC_START
#define SND_PCM_STATE_OPEN SNDRV_PCM_STATE_OPEN
#define SND_PCM_STATE_SETUP SNDRV_PCM_STATE_SETUP
#define SND_PCM_STATE_PREPARED SNDRV_PCM_STATE_PREPARED
#define SND_PCM_STATE_RUNNING SNDRV_PCM_STATE_RUNNING
#define SND_PCM_STATE_XRUN SNDRV_PCM_STATE_XRUN
#define SND_PCM_STATE_DRAINING SNDRV_PCM_STATE_DRAINING
#define SND_PCM_STATE_PAUSED SNDRV_PCM_STATE_PAUSED
#define SND_PCM_STATE_LAST SNDRV_PCM_STATE_LAST
#define SND_PCM_MMAP_OFFSET_DATA SNDRV_PCM_MMAP_OFFSET_DATA
#define SND_PCM_MMAP_OFFSET_STATUS SNDRV_PCM_MMAP_OFFSET_STATUS
#define SND_PCM_MMAP_OFFSET_CONTROL SNDRV_PCM_MMAP_OFFSET_CONTROL
#define SND_PCM_HW_PARAM_ACCESS SNDRV_PCM_HW_PARAM_ACCESS
#define SND_PCM_HW_PARAM_FIRST_MASK SNDRV_PCM_HW_PARAM_FIRST_MASK
#define SND_PCM_HW_PARAM_FORMAT SNDRV_PCM_HW_PARAM_FORMAT
#define SND_PCM_HW_PARAM_SUBFORMAT SNDRV_PCM_HW_PARAM_SUBFORMAT
#define SND_PCM_HW_PARAM_LAST_MASK SNDRV_PCM_HW_PARAM_LAST_MASK
#define SND_PCM_HW_PARAM_SAMPLE_BITS SNDRV_PCM_HW_PARAM_SAMPLE_BITS
#define SND_PCM_HW_PARAM_FIRST_INTERVAL SNDRV_PCM_HW_PARAM_FIRST_INTERVAL
#define SND_PCM_HW_PARAM_FRAME_BITS SNDRV_PCM_HW_PARAM_FRAME_BITS
#define SND_PCM_HW_PARAM_CHANNELS SNDRV_PCM_HW_PARAM_CHANNELS
#define SND_PCM_HW_PARAM_RATE SNDRV_PCM_HW_PARAM_RATE
#define SND_PCM_HW_PARAM_PERIOD_TIME SNDRV_PCM_HW_PARAM_PERIOD_TIME
#define SND_PCM_HW_PARAM_PERIOD_SIZE SNDRV_PCM_HW_PARAM_PERIOD_SIZE
#define SND_PCM_HW_PARAM_PERIOD_BYTES SNDRV_PCM_HW_PARAM_PERIOD_BYTES
#define SND_PCM_HW_PARAM_PERIODS SNDRV_PCM_HW_PARAM_PERIODS
#define SND_PCM_HW_PARAM_BUFFER_TIME SNDRV_PCM_HW_PARAM_BUFFER_TIME
#define SND_PCM_HW_PARAM_BUFFER_SIZE SNDRV_PCM_HW_PARAM_BUFFER_SIZE
#define SND_PCM_HW_PARAM_BUFFER_BYTES SNDRV_PCM_HW_PARAM_BUFFER_BYTES
#define SND_PCM_HW_PARAM_TICK_TIME SNDRV_PCM_HW_PARAM_TICK_TIME
#define SND_PCM_HW_PARAM_LAST_INTERVAL SNDRV_PCM_HW_PARAM_LAST_INTERVAL
#define SND_PCM_HW_PARAM_LAST SNDRV_PCM_HW_PARAM_LAST
#define SND_PCM_HW_PARAMS_RUNTIME SNDRV_PCM_HW_PARAMS_RUNTIME
#define SND_PCM_HW_PARAM_LAST_MASK SNDRV_PCM_HW_PARAM_LAST_MASK
#define SND_PCM_HW_PARAM_FIRST_MASK SNDRV_PCM_HW_PARAM_FIRST_MASK
#define SND_PCM_HW_PARAM_LAST_INTERVAL SNDRV_PCM_HW_PARAM_LAST_INTERVAL
#define SND_PCM_HW_PARAM_FIRST_INTERVAL SNDRV_PCM_HW_PARAM_FIRST_INTERVAL
#define SND_PCM_START_DATA SNDRV_PCM_START_DATA
#define SND_PCM_START_EXPLICIT SNDRV_PCM_START_EXPLICIT
#define SND_PCM_START_LAST SNDRV_PCM_START_LAST
#define SND_PCM_XRUN_NONE SNDRV_PCM_XRUN_NONE
#define SND_PCM_XRUN_STOP SNDRV_PCM_XRUN_STOP
#define SND_PCM_XRUN_LAST SNDRV_PCM_XRUN_LAST
#define SND_PCM_TSTAMP_NONE SNDRV_PCM_TSTAMP_NONE
#define SND_PCM_TSTAMP_MMAP SNDRV_PCM_TSTAMP_MMAP
#define SND_PCM_TSTAMP_LAST SNDRV_PCM_TSTAMP_LAST
#define SND_PCM_STATE_XXXX SNDRV_PCM_STATE_XXXX
#define SND_PCM_NONBLOCK 0x0001
#define SND_PCM_ASYNC 0x0002
#ifdef __cplusplus
extern "C" {
#endif
typedef struct _snd_pcm snd_pcm_t;
typedef enum _snd_pcm_type {
@ -41,6 +182,10 @@ typedef struct _snd_pcm_channel_area {
unsigned int step; /* samples distance in bits */
} snd_pcm_channel_area_t;
#ifdef __cplusplus
extern "C" {
#endif
int snd_pcm_open(snd_pcm_t **pcm, char *name,
int stream, int mode);
@ -89,20 +234,20 @@ int snd_pcm_wait(snd_pcm_t *pcm, int timeout);
snd_pcm_sframes_t snd_pcm_avail_update(snd_pcm_t *pcm);
int snd_pcm_set_avail_min(snd_pcm_t *pcm, snd_pcm_uframes_t size);
typedef struct _mask mask_t;
size_t mask_sizeof();
void mask_none(mask_t *mask);
void mask_any(mask_t *mask);
void mask_load(mask_t *mask, unsigned int msk);
int mask_empty(const mask_t *mask);
void mask_set(mask_t *mask, unsigned int val);
void mask_reset(mask_t *mask, unsigned int val);
void mask_copy(mask_t *mask, const mask_t *v);
int mask_test(const mask_t *mask, unsigned int val);
void mask_intersect(mask_t *mask, const mask_t *v);
void mask_union(mask_t *mask, const mask_t *v);
int mask_eq(const mask_t *a, const mask_t *b);
int mask_single(const mask_t *mask);
typedef struct _snd_mask snd_mask_t;
size_t snd_mask_sizeof();
void snd_mask_none(snd_mask_t *mask);
void snd_mask_any(snd_mask_t *mask);
void snd_mask_load(snd_mask_t *mask, unsigned int msk);
int snd_mask_empty(const snd_mask_t *mask);
void snd_mask_set(snd_mask_t *mask, unsigned int val);
void snd_mask_reset(snd_mask_t *mask, unsigned int val);
void snd_mask_copy(snd_mask_t *mask, const snd_mask_t *v);
int snd_mask_test(const snd_mask_t *mask, unsigned int val);
void snd_mask_intersect(snd_mask_t *mask, const snd_mask_t *v);
void snd_mask_union(snd_mask_t *mask, const snd_mask_t *v);
int snd_mask_eq(const snd_mask_t *a, const snd_mask_t *b);
int snd_mask_single(const snd_mask_t *mask);
int snd_pcm_hw_params_any(snd_pcm_t *pcm, snd_pcm_hw_params_t *params);
int snd_pcm_hw_param_any(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
@ -130,7 +275,7 @@ int snd_pcm_hw_param_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
int snd_pcm_hw_param_set(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var, unsigned int val, int dir);
int snd_pcm_hw_param_mask(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var, const mask_t *mask);
snd_pcm_hw_param_t var, const snd_mask_t *mask);
int snd_pcm_hw_param_min_try(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var,
unsigned int val, int *dir);
@ -143,13 +288,13 @@ int snd_pcm_hw_param_minmax_try(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
unsigned int *max, int *maxdir);
int snd_pcm_hw_param_set_try(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var, unsigned int val, int dir);
int snd_pcm_hw_param_mask_try(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var, const mask_t *mask);
int snd_pcm_hw_param_snd_mask_try(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var, const snd_mask_t *mask);
int snd_pcm_hw_param_value(const snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var, int *dir);
const mask_t *snd_pcm_hw_param_value_mask(const snd_pcm_hw_params_t *params,
const snd_mask_t *snd_pcm_hw_param_value_mask(const snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var);
const interval_t *snd_pcm_hw_param_value_interval(const snd_pcm_hw_params_t *params,
const snd_interval_t *snd_pcm_hw_param_value_interval(const snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var);
unsigned int snd_pcm_hw_param_value_min(const snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var, int *dir);

22
include/rawmidi.h
View file

@ -5,6 +5,20 @@
* *
****************************************************************************/
typedef enum sndrv_rawmidi_stream snd_rawmidi_stream_t;
typedef struct sndrv_rawmidi_info snd_rawmidi_info_t;
typedef struct sndrv_rawmidi_params snd_rawmidi_params_t;
typedef struct sndrv_rawmidi_status snd_rawmidi_status_t;
#define SND_RAWMIDI_STREAM_OUTPUT SNDRV_RAWMIDI_STREAM_OUTPUT
#define SND_RAWMIDI_STREAM_INPUT SNDRV_RAWMIDI_STREAM_INPUT
#define SND_RAWMIDI_INFO_OUTPUT SNDRV_RAWMIDI_INFO_OUTPUT
#define SND_RAWMIDI_INFO_INPUT SNDRV_RAWMIDI_INFO_INPUT
#define SND_RAWMIDI_INFO_DUPLEX SNDRV_RAWMIDI_INFO_DUPLEX
#define SND_RAWMIDI_INFO_XXXX SNDRV_RAWMIDI_INFO_XXXX
#define SND_RAWMIDI_PARBIT_STREAM SNDRV_RAWMIDI_PARBIT_STREAM
#define SND_RAWMIDI_PARBIT_BUFFER_SIZE SNDRV_RAWMIDI_PARBIT_BUFFER_SIZE
#define SND_RAWMIDI_PARBIT_AVAIL_MIN SNDRV_RAWMIDI_PARBIT_AVAIL_MIN
#define SND_RAWMIDI_OPEN_OUTPUT (1<<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)
@ -12,10 +26,6 @@
#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 {
@ -24,6 +34,10 @@ 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);

297
include/seq.h
View file

@ -5,16 +5,301 @@
* *
****************************************************************************/
/* 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,
@ -23,6 +308,10 @@ typedef enum _snd_seq_type {
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);

31
include/timer.h
View file

@ -5,12 +5,39 @@
* *
****************************************************************************/
/* 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);

88
src/pcm/interval.c
View file

@ -19,8 +19,8 @@
*
*/
#define INTERVAL_C
#define INTERVAL_INLINE
#define SND_INTERVAL_C
#define SND_INTERVAL_INLINE
#include <sys/types.h>
#include <limits.h>
@ -105,10 +105,10 @@ static inline unsigned int muldiv32(unsigned int a, unsigned int b,
return n;
}
int interval_refine_min(interval_t *i, unsigned int min, int openmin)
int snd_interval_refine_min(snd_interval_t *i, unsigned int min, int openmin)
{
int changed = 0;
assert(!interval_empty(i));
assert(!snd_interval_empty(i));
if (i->min < min) {
i->min = min;
i->openmin = openmin;
@ -123,17 +123,17 @@ int interval_refine_min(interval_t *i, unsigned int min, int openmin)
i->openmin = 0;
}
}
if (interval_checkempty(i)) {
interval_none(i);
if (snd_interval_checkempty(i)) {
snd_interval_none(i);
return -EINVAL;
}
return changed;
}
int interval_refine_max(interval_t *i, unsigned int max, int openmax)
int snd_interval_refine_max(snd_interval_t *i, unsigned int max, int openmax)
{
int changed = 0;
assert(!interval_empty(i));
assert(!snd_interval_empty(i));
if (i->max > max) {
i->max = max;
i->openmax = openmax;
@ -148,18 +148,18 @@ int interval_refine_max(interval_t *i, unsigned int max, int openmax)
i->openmax = 0;
}
}
if (interval_checkempty(i)) {
interval_none(i);
if (snd_interval_checkempty(i)) {
snd_interval_none(i);
return -EINVAL;
}
return changed;
}
/* r <- v */
int interval_refine(interval_t *i, const interval_t *v)
int snd_interval_refine(snd_interval_t *i, const snd_interval_t *v)
{
int changed = 0;
assert(!interval_empty(i));
assert(!snd_interval_empty(i));
if (i->min < v->min) {
i->min = v->min;
i->openmin = v->openmin;
@ -191,17 +191,17 @@ int interval_refine(interval_t *i, const interval_t *v)
}
} else if (!i->openmin && !i->openmax && i->min == i->max)
i->integer = 1;
if (interval_checkempty(i)) {
interval_none(i);
if (snd_interval_checkempty(i)) {
snd_interval_none(i);
return -EINVAL;
}
return changed;
}
int interval_refine_first(interval_t *i)
int snd_interval_refine_first(snd_interval_t *i)
{
assert(!interval_empty(i));
if (interval_single(i))
assert(!snd_interval_empty(i));
if (snd_interval_single(i))
return 0;
i->max = i->min;
i->openmax = i->openmin;
@ -210,10 +210,10 @@ int interval_refine_first(interval_t *i)
return 1;
}
int interval_refine_last(interval_t *i)
int snd_interval_refine_last(snd_interval_t *i)
{
assert(!interval_empty(i));
if (interval_single(i))
assert(!snd_interval_empty(i));
if (snd_interval_single(i))
return 0;
i->min = i->max;
i->openmin = i->openmax;
@ -222,20 +222,20 @@ int interval_refine_last(interval_t *i)
return 1;
}
int interval_refine_set(interval_t *i, unsigned int val)
int snd_interval_refine_set(snd_interval_t *i, unsigned int val)
{
interval_t t;
snd_interval_t t;
t.empty = 0;
t.min = t.max = val;
t.openmin = t.openmax = 0;
t.integer = 1;
return interval_refine(i, &t);
return snd_interval_refine(i, &t);
}
void interval_add(const interval_t *a, const interval_t *b, interval_t *c)
void snd_interval_add(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c)
{
if (a->empty || b->empty) {
interval_none(c);
snd_interval_none(c);
return;
}
c->empty = 0;
@ -246,10 +246,10 @@ void interval_add(const interval_t *a, const interval_t *b, interval_t *c)
c->integer = (a->integer && b->integer);
}
void interval_sub(const interval_t *a, const interval_t *b, interval_t *c)
void snd_interval_sub(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c)
{
if (a->empty || b->empty) {
interval_none(c);
snd_interval_none(c);
return;
}
c->empty = 0;
@ -260,10 +260,10 @@ void interval_sub(const interval_t *a, const interval_t *b, interval_t *c)
c->integer = (a->integer && b->integer);
}
void interval_mul(const interval_t *a, const interval_t *b, interval_t *c)
void snd_interval_mul(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c)
{
if (a->empty || b->empty) {
interval_none(c);
snd_interval_none(c);
return;
}
c->empty = 0;
@ -274,11 +274,11 @@ void interval_mul(const interval_t *a, const interval_t *b, interval_t *c)
c->integer = (a->integer && b->integer);
}
void interval_div(const interval_t *a, const interval_t *b, interval_t *c)
void snd_interval_div(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c)
{
unsigned int r;
if (a->empty || b->empty) {
interval_none(c);
snd_interval_none(c);
return;
}
c->empty = 0;
@ -299,12 +299,12 @@ void interval_div(const interval_t *a, const interval_t *b, interval_t *c)
}
/* a * b / c */
void interval_muldiv(const interval_t *a, const interval_t *b,
const interval_t *c, interval_t *d)
void snd_interval_muldiv(const snd_interval_t *a, const snd_interval_t *b,
const snd_interval_t *c, snd_interval_t *d)
{
unsigned int r;
if (a->empty || b->empty || c->empty) {
interval_none(d);
snd_interval_none(d);
return;
}
d->empty = 0;
@ -320,12 +320,12 @@ void interval_muldiv(const interval_t *a, const interval_t *b,
}
/* a * b / k */
void interval_muldivk(const interval_t *a, const interval_t *b,
unsigned int k, interval_t *c)
void snd_interval_muldivk(const snd_interval_t *a, const snd_interval_t *b,
unsigned int k, snd_interval_t *c)
{
unsigned int r;
if (a->empty || b->empty) {
interval_none(c);
snd_interval_none(c);
return;
}
c->empty = 0;
@ -341,12 +341,12 @@ void interval_muldivk(const interval_t *a, const interval_t *b,
}
/* a * k / b */
void interval_mulkdiv(const interval_t *a, unsigned int k,
const interval_t *b, interval_t *c)
void snd_interval_mulkdiv(const snd_interval_t *a, unsigned int k,
const snd_interval_t *b, snd_interval_t *c)
{
unsigned int r;
if (a->empty || b->empty) {
interval_none(c);
snd_interval_none(c);
return;
}
c->empty = 0;
@ -366,15 +366,15 @@ void interval_mulkdiv(const interval_t *a, unsigned int k,
c->integer = 0;
}
void interval_print(const interval_t *i, snd_output_t *out)
void snd_interval_print(const snd_interval_t *i, snd_output_t *out)
{
if (interval_empty(i))
if (snd_interval_empty(i))
snd_output_printf(out, "NONE");
else if (i->min == 0 && i->openmin == 0 &&
i->max == UINT_MAX && i->openmax == 0)
snd_output_printf(out, "ALL");
else if (interval_single(i) && i->integer)
snd_output_printf(out, "%u", interval_value(i));
else if (snd_interval_single(i) && i->integer)
snd_output_printf(out, "%u", snd_interval_value(i));
else
snd_output_printf(out, "%c%u %u%c",
i->openmin ? '(' : '[',

64
src/pcm/interval.h
View file

@ -21,42 +21,42 @@
#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);

48
src/pcm/interval_inline.h
View file

@ -19,13 +19,13 @@
*
*/
#ifdef INTERVAL_C
#ifdef SND_INTERVAL_C
#define INLINE inline
#else
#define INLINE extern inline
#endif
INLINE void interval_any(interval_t *i)
INLINE void snd_interval_any(snd_interval_t *i)
{
i->min = 0;
i->openmin = 0;
@ -35,59 +35,59 @@ INLINE void interval_any(interval_t *i)
i->empty = 0;
}
INLINE void interval_none(interval_t *i)
INLINE void snd_interval_none(snd_interval_t *i)
{
i->empty = 1;
}
INLINE int interval_checkempty(const interval_t *i)
INLINE int snd_interval_checkempty(const snd_interval_t *i)
{
return (i->min > i->max ||
(i->min == i->max && (i->openmin || i->openmax)));
}
INLINE int interval_empty(const interval_t *i)
INLINE int snd_interval_empty(const snd_interval_t *i)
{
return i->empty;
}
INLINE int interval_single(const interval_t *i)
INLINE int snd_interval_single(const snd_interval_t *i)
{
assert(!interval_empty(i));
assert(!snd_interval_empty(i));
return (i->min == i->max ||
(i->min + 1 == i->max && i->openmax));
}
INLINE int interval_value(const interval_t *i)
INLINE int snd_interval_value(const snd_interval_t *i)
{
assert(interval_single(i));
assert(snd_interval_single(i));
return i->min;
}
INLINE int interval_min(const interval_t *i)
INLINE int snd_interval_min(const snd_interval_t *i)
{
assert(!interval_empty(i));
assert(!snd_interval_empty(i));
return i->min;
}
INLINE int interval_max(const interval_t *i)
INLINE int snd_interval_max(const snd_interval_t *i)
{
assert(!interval_empty(i));
assert(!snd_interval_empty(i));
return i->max;
}
INLINE int interval_test(const interval_t *i, unsigned int val)
INLINE int snd_interval_test(const snd_interval_t *i, unsigned int val)
{
return !((i->min > val || (i->min == val && i->openmin) ||
i->max < val || (i->max == val && i->openmax)));
}
INLINE void interval_copy(interval_t *d, const interval_t *s)
INLINE void snd_interval_copy(snd_interval_t *d, const snd_interval_t *s)
{
*d = *s;
}
INLINE int interval_setinteger(interval_t *i)
INLINE int snd_interval_setinteger(snd_interval_t *i)
{
if (i->integer)
return 0;
@ -97,9 +97,9 @@ INLINE int interval_setinteger(interval_t *i)
return 1;
}
INLINE void interval_floor(interval_t *i)
INLINE void snd_interval_floor(snd_interval_t *i)
{
if (i->integer || interval_empty(i))
if (i->integer || snd_interval_empty(i))
return;
i->openmin = 0;
if (i->openmax) {
@ -109,9 +109,9 @@ INLINE void interval_floor(interval_t *i)
i->integer = 1;
}
INLINE void interval_unfloor(interval_t *i)
INLINE void snd_interval_unfloor(snd_interval_t *i)
{
if (interval_empty(i))
if (snd_interval_empty(i))
return;
if (i->max == UINT_MAX)
return;
@ -123,13 +123,13 @@ INLINE void interval_unfloor(interval_t *i)
}
INLINE int interval_always_eq(const interval_t *i1, const interval_t *i2)
INLINE int snd_interval_always_eq(const snd_interval_t *i1, const snd_interval_t *i2)
{
return interval_single(i1) && interval_single(i2) &&
interval_value(i1) == interval_value(i2);
return snd_interval_single(i1) && snd_interval_single(i2) &&
snd_interval_value(i1) == snd_interval_value(i2);
}
INLINE int interval_never_eq(const interval_t *i1, const interval_t *i2)
INLINE int snd_interval_never_eq(const snd_interval_t *i1, const snd_interval_t *i2)
{
return (i1->max < i2->min ||

4
src/pcm/mask.c
View file

@ -19,8 +19,8 @@
*
*/
#define MASK_C
#define MASK_INLINE
#define SND_MASK_C
#define SND_MASK_INLINE
#include <sys/types.h>
#include <limits.h>

60
src/pcm/mask.h
View file

@ -25,37 +25,37 @@
#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

180
src/pcm/mask_inline.h
View file

@ -22,7 +22,7 @@
#include <sys/types.h>
#include <assert.h>
#ifdef MASK_C
#ifdef SND_MASK_C
#define INLINE inline
#else
#define INLINE extern inline
@ -32,11 +32,11 @@
#define MASK_MAX 31
#endif
struct _mask {
struct _snd_mask {
unsigned int bits;
};
#define mask_bits(mask) ((mask)->bits)
#define snd_mask_bits(mask) ((mask)->bits)
INLINE unsigned int ld2(u_int32_t v)
{
@ -72,190 +72,190 @@ INLINE unsigned int hweight32(u_int32_t v)
return (v & 0x0000FFFF) + ((v >> 16) & 0x0000FFFF);
}
INLINE size_t mask_sizeof(void)
INLINE size_t snd_mask_sizeof(void)
{
return sizeof(mask_t);
return sizeof(snd_mask_t);
}
INLINE void mask_none(mask_t *mask)
INLINE void snd_mask_none(snd_mask_t *mask)
{
mask_bits(mask) = 0;
snd_mask_bits(mask) = 0;
}
INLINE void mask_any(mask_t *mask)
INLINE void snd_mask_any(snd_mask_t *mask)
{
mask_bits(mask) = ~0U;
snd_mask_bits(mask) = ~0U;
}
INLINE void mask_load(mask_t *mask, unsigned int msk)
INLINE void snd_mask_load(snd_mask_t *mask, unsigned int msk)
{
mask_bits(mask) = msk;
snd_mask_bits(mask) = msk;
}
INLINE int mask_empty(const mask_t *mask)
INLINE int snd_mask_empty(const snd_mask_t *mask)
{
return mask_bits(mask) == 0;
return snd_mask_bits(mask) == 0;
}
INLINE int mask_full(const mask_t *mask)
INLINE int snd_mask_full(const snd_mask_t *mask)
{
return mask_bits(mask) == ~0U;
return snd_mask_bits(mask) == ~0U;
}
INLINE unsigned int mask_count(const mask_t *mask)
INLINE unsigned int snd_mask_count(const snd_mask_t *mask)
{
return hweight32(mask_bits(mask));
return hweight32(snd_mask_bits(mask));
}
INLINE unsigned int mask_min(const mask_t *mask)
INLINE unsigned int snd_mask_min(const snd_mask_t *mask)
{
assert(!mask_empty(mask));
return ffs(mask_bits(mask)) - 1;
assert(!snd_mask_empty(mask));
return ffs(snd_mask_bits(mask)) - 1;
}
INLINE unsigned int mask_max(const mask_t *mask)
INLINE unsigned int snd_mask_max(const snd_mask_t *mask)
{
assert(!mask_empty(mask));
return ld2(mask_bits(mask));
assert(!snd_mask_empty(mask));
return ld2(snd_mask_bits(mask));
}
INLINE void mask_set(mask_t *mask, unsigned int val)
INLINE void snd_mask_set(snd_mask_t *mask, unsigned int val)
{
assert(val <= MASK_MAX);
mask_bits(mask) |= (1U << val);
assert(val <= SND_MASK_MAX);
snd_mask_bits(mask) |= (1U << val);
}
INLINE void mask_reset(mask_t *mask, unsigned int val)
INLINE void snd_mask_reset(snd_mask_t *mask, unsigned int val)
{
assert(val <= MASK_MAX);
mask_bits(mask) &= ~(1U << val);
assert(val <= SND_MASK_MAX);
snd_mask_bits(mask) &= ~(1U << val);
}
INLINE void mask_set_range(mask_t *mask, unsigned int from, unsigned int to)
INLINE void snd_mask_set_range(snd_mask_t *mask, unsigned int from, unsigned int to)
{
assert(to <= MASK_MAX && from <= to);
mask_bits(mask) |= ((1U << (from - to + 1)) - 1) << from;
assert(to <= SND_MASK_MAX && from <= to);
snd_mask_bits(mask) |= ((1U << (from - to + 1)) - 1) << from;
}
INLINE void mask_reset_range(mask_t *mask, unsigned int from, unsigned int to)
INLINE void snd_mask_reset_range(snd_mask_t *mask, unsigned int from, unsigned int to)
{
assert(to <= MASK_MAX && from <= to);
mask_bits(mask) &= ~(((1U << (from - to + 1)) - 1) << from);
assert(to <= SND_MASK_MAX && from <= to);
snd_mask_bits(mask) &= ~(((1U << (from - to + 1)) - 1) << from);
}
INLINE void mask_leave(mask_t *mask, unsigned int val)
INLINE void snd_mask_leave(snd_mask_t *mask, unsigned int val)
{
assert(val <= MASK_MAX);
mask_bits(mask) &= 1U << val;
assert(val <= SND_MASK_MAX);
snd_mask_bits(mask) &= 1U << val;
}
INLINE void mask_intersect(mask_t *mask, const mask_t *v)
INLINE void snd_mask_intersect(snd_mask_t *mask, const snd_mask_t *v)
{
mask_bits(mask) &= mask_bits(v);
snd_mask_bits(mask) &= snd_mask_bits(v);
}
INLINE void mask_union(mask_t *mask, const mask_t *v)
INLINE void snd_mask_union(snd_mask_t *mask, const snd_mask_t *v)
{
mask_bits(mask) |= mask_bits(v);
snd_mask_bits(mask) |= snd_mask_bits(v);
}
INLINE int mask_eq(const mask_t *mask, const mask_t *v)
INLINE int snd_mask_eq(const snd_mask_t *mask, const snd_mask_t *v)
{
return mask_bits(mask) == mask_bits(v);
return snd_mask_bits(mask) == snd_mask_bits(v);
}
INLINE void mask_copy(mask_t *mask, const mask_t *v)
INLINE void snd_mask_copy(snd_mask_t *mask, const snd_mask_t *v)
{
mask_bits(mask) = mask_bits(v);
snd_mask_bits(mask) = snd_mask_bits(v);
}
INLINE int mask_test(const mask_t *mask, unsigned int val)
INLINE int snd_mask_test(const snd_mask_t *mask, unsigned int val)
{
assert(val <= MASK_MAX);
return mask_bits(mask) & (1U << val);
assert(val <= SND_MASK_MAX);
return snd_mask_bits(mask) & (1U << val);
}
INLINE int mask_single(const mask_t *mask)
INLINE int snd_mask_single(const snd_mask_t *mask)
{
assert(!mask_empty(mask));
return !(mask_bits(mask) & (mask_bits(mask) - 1));
assert(!snd_mask_empty(mask));
return !(snd_mask_bits(mask) & (snd_mask_bits(mask) - 1));
}
INLINE int mask_refine(mask_t *mask, const mask_t *v)
INLINE int snd_mask_refine(snd_mask_t *mask, const snd_mask_t *v)
{
mask_t old;
assert(!mask_empty(mask));
mask_copy(&old, mask);
mask_intersect(mask, v);
if (mask_empty(mask))
snd_mask_t old;
assert(!snd_mask_empty(mask));
snd_mask_copy(&old, mask);
snd_mask_intersect(mask, v);
if (snd_mask_empty(mask))
return -EINVAL;
return !mask_eq(mask, &old);
return !snd_mask_eq(mask, &old);
}
INLINE int mask_refine_first(mask_t *mask)
INLINE int snd_mask_refine_first(snd_mask_t *mask)
{
assert(!mask_empty(mask));
if (mask_single(mask))
assert(!snd_mask_empty(mask));
if (snd_mask_single(mask))
return 0;
mask_leave(mask, mask_min(mask));
snd_mask_leave(mask, snd_mask_min(mask));
return 1;
}
INLINE int mask_refine_last(mask_t *mask)
INLINE int snd_mask_refine_last(snd_mask_t *mask)
{
assert(!mask_empty(mask));
if (mask_single(mask))
assert(!snd_mask_empty(mask));
if (snd_mask_single(mask))
return 0;
mask_leave(mask, mask_max(mask));
snd_mask_leave(mask, snd_mask_max(mask));
return 1;
}
INLINE int mask_refine_min(mask_t *mask, unsigned int val)
INLINE int snd_mask_refine_min(snd_mask_t *mask, unsigned int val)
{
assert(!mask_empty(mask));
if (mask_min(mask) >= val)
assert(!snd_mask_empty(mask));
if (snd_mask_min(mask) >= val)
return 0;
mask_reset_range(mask, 0, val - 1);
if (mask_empty(mask))
snd_mask_reset_range(mask, 0, val - 1);
if (snd_mask_empty(mask))
return -EINVAL;
return 1;
}
INLINE int mask_refine_max(mask_t *mask, unsigned int val)
INLINE int snd_mask_refine_max(snd_mask_t *mask, unsigned int val)
{
assert(!mask_empty(mask));
if (mask_max(mask) <= val)
assert(!snd_mask_empty(mask));
if (snd_mask_max(mask) <= val)
return 0;
mask_reset_range(mask, val + 1, MASK_MAX);
if (mask_empty(mask))
snd_mask_reset_range(mask, val + 1, SND_MASK_MAX);
if (snd_mask_empty(mask))
return -EINVAL;
return 1;
}
INLINE int mask_refine_set(mask_t *mask, unsigned int val)
INLINE int snd_mask_refine_set(snd_mask_t *mask, unsigned int val)
{
int changed;
assert(!mask_empty(mask));
changed = !mask_single(mask);
mask_leave(mask, val);
if (mask_empty(mask))
assert(!snd_mask_empty(mask));
changed = !snd_mask_single(mask);
snd_mask_leave(mask, val);
if (snd_mask_empty(mask))
return -EINVAL;
return changed;
}
INLINE int mask_value(const mask_t *mask)
INLINE int snd_mask_value(const snd_mask_t *mask)
{
assert(!mask_empty(mask));
return mask_min(mask);
assert(!snd_mask_empty(mask));
return snd_mask_min(mask);
}
INLINE int mask_always_eq(const mask_t *m1, const mask_t *m2)
INLINE int snd_mask_always_eq(const snd_mask_t *m1, const snd_mask_t *m2)
{
return mask_single(m1) && mask_single(m2) &&
mask_value(m1) == mask_value(m2);
return snd_mask_single(m1) && snd_mask_single(m2) &&
snd_mask_value(m1) == snd_mask_value(m2);
}
INLINE int mask_never_eq(const mask_t *m1, const mask_t *m2)
INLINE int snd_mask_never_eq(const snd_mask_t *m1, const snd_mask_t *m2)
{
return (mask_bits(m1) & mask_bits(m2)) == 0;
return (snd_mask_bits(m1) & snd_mask_bits(m2)) == 0;
}

12
src/pcm/pcm_adpcm.c
View file

@ -316,15 +316,15 @@ static int snd_pcm_adpcm_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t
{
snd_pcm_adpcm_t *adpcm = pcm->private;
int err;
mask_t *access_mask = alloca(mask_sizeof());
mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN);
snd_mask_t *access_mask = alloca(snd_mask_sizeof());
snd_mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN);
err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS,
access_mask);
if (err < 0)
return err;
if (adpcm->sformat == SND_PCM_FORMAT_IMA_ADPCM) {
mask_t *format_mask = alloca(mask_sizeof());
mask_load(format_mask, SND_PCM_FMTBIT_LINEAR);
snd_mask_t *format_mask = alloca(snd_mask_sizeof());
snd_mask_load(format_mask, SND_PCM_FMTBIT_LINEAR);
err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_FORMAT,
format_mask);
} else {
@ -345,8 +345,8 @@ static int snd_pcm_adpcm_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t
static int snd_pcm_adpcm_hw_refine_sprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *sparams)
{
snd_pcm_adpcm_t *adpcm = pcm->private;
mask_t *saccess_mask = alloca(mask_sizeof());
mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
snd_mask_t *saccess_mask = alloca(snd_mask_sizeof());
snd_mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
_snd_pcm_hw_params_any(sparams);
_snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
saccess_mask);

12
src/pcm/pcm_alaw.c
View file

@ -215,15 +215,15 @@ static int snd_pcm_alaw_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *
{
snd_pcm_alaw_t *alaw = pcm->private;
int err;
mask_t *access_mask = alloca(mask_sizeof());
mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN);
snd_mask_t *access_mask = alloca(snd_mask_sizeof());
snd_mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN);
err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS,
access_mask);
if (err < 0)
return err;
if (alaw->sformat == SND_PCM_FORMAT_A_LAW) {
mask_t *format_mask = alloca(mask_sizeof());
mask_load(format_mask, SND_PCM_FMTBIT_LINEAR);
snd_mask_t *format_mask = alloca(snd_mask_sizeof());
snd_mask_load(format_mask, SND_PCM_FMTBIT_LINEAR);
err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_FORMAT,
format_mask);
} else {
@ -244,8 +244,8 @@ static int snd_pcm_alaw_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *
static int snd_pcm_alaw_hw_refine_sprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *sparams)
{
snd_pcm_alaw_t *alaw = pcm->private;
mask_t *saccess_mask = alloca(mask_sizeof());
mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
snd_mask_t *saccess_mask = alloca(snd_mask_sizeof());
snd_mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
_snd_pcm_hw_params_any(sparams);
_snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
saccess_mask);

8
src/pcm/pcm_copy.c
View file

@ -31,8 +31,8 @@ typedef struct {
static int snd_pcm_copy_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *params)
{
int err;
mask_t *access_mask = alloca(mask_sizeof());
mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN);
snd_mask_t *access_mask = alloca(snd_mask_sizeof());
snd_mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN);
err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS,
access_mask);
if (err < 0)
@ -43,8 +43,8 @@ static int snd_pcm_copy_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_
static int snd_pcm_copy_hw_refine_sprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *sparams)
{
mask_t *saccess_mask = alloca(mask_sizeof());
mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
snd_mask_t *saccess_mask = alloca(snd_mask_sizeof());
snd_mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
_snd_pcm_hw_params_any(sparams);
_snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
saccess_mask);

16
src/pcm/pcm_hw.c
View file

@ -44,8 +44,8 @@
typedef struct {
int fd;
int card, device, subdevice;
volatile snd_pcm_mmap_status_t *mmap_status;
snd_pcm_mmap_control_t *mmap_control;
volatile struct sndrv_pcm_mmap_status *mmap_status;
struct sndrv_pcm_mmap_control *mmap_control;
int shmid;
} snd_pcm_hw_t;
@ -318,7 +318,7 @@ static snd_pcm_sframes_t snd_pcm_hw_writei(snd_pcm_t *pcm, const void *buffer, s
snd_pcm_sframes_t result;
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
snd_xferi_t xferi;
struct sndrv_xferi xferi;
xferi.buf = (char*) buffer;
xferi.frames = size;
result = ioctl(fd, SNDRV_PCM_IOCTL_WRITEI_FRAMES, &xferi);
@ -332,7 +332,7 @@ static snd_pcm_sframes_t snd_pcm_hw_writen(snd_pcm_t *pcm, void **bufs, snd_pcm_
snd_pcm_sframes_t result;
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
snd_xfern_t xfern;
struct sndrv_xfern xfern;
xfern.bufs = bufs;
xfern.frames = size;
result = ioctl(fd, SNDRV_PCM_IOCTL_WRITEN_FRAMES, &xfern);
@ -346,7 +346,7 @@ static snd_pcm_sframes_t snd_pcm_hw_readi(snd_pcm_t *pcm, void *buffer, snd_pcm_
snd_pcm_sframes_t result;
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
snd_xferi_t xferi;
struct sndrv_xferi xferi;
xferi.buf = buffer;
xferi.frames = size;
result = ioctl(fd, SNDRV_PCM_IOCTL_READI_FRAMES, &xferi);
@ -360,7 +360,7 @@ snd_pcm_sframes_t snd_pcm_hw_readn(snd_pcm_t *pcm, void **bufs, snd_pcm_uframes_
snd_pcm_sframes_t result;
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
snd_xfern_t xfern;
struct sndrv_xfern xfern;
xfern.bufs = bufs;
xfern.frames = size;
result = ioctl(fd, SNDRV_PCM_IOCTL_READN_FRAMES, &xfern);
@ -373,7 +373,7 @@ static int snd_pcm_hw_mmap_status(snd_pcm_t *pcm)
{
snd_pcm_hw_t *hw = pcm->private;
void *ptr;
ptr = mmap(NULL, PAGE_ALIGN(sizeof(snd_pcm_mmap_status_t)), PROT_READ, MAP_FILE|MAP_SHARED,
ptr = mmap(NULL, PAGE_ALIGN(sizeof(struct sndrv_pcm_mmap_status)), PROT_READ, MAP_FILE|MAP_SHARED,
hw->fd, SND_PCM_MMAP_OFFSET_STATUS);
if (ptr == MAP_FAILED || ptr == NULL) {
SYSERR("status mmap failed");
@ -388,7 +388,7 @@ static int snd_pcm_hw_mmap_control(snd_pcm_t *pcm)
{
snd_pcm_hw_t *hw = pcm->private;
void *ptr;
ptr = mmap(NULL, PAGE_ALIGN(sizeof(snd_pcm_mmap_control_t)), PROT_READ|PROT_WRITE, MAP_FILE|MAP_SHARED,
ptr = mmap(NULL, PAGE_ALIGN(sizeof(struct sndrv_pcm_mmap_control)), PROT_READ|PROT_WRITE, MAP_FILE|MAP_SHARED,
hw->fd, SND_PCM_MMAP_OFFSET_CONTROL);
if (ptr == MAP_FAILED || ptr == NULL) {
SYSERR("control mmap failed");

12
src/pcm/pcm_linear.c
View file

@ -132,10 +132,10 @@ void snd_pcm_linear_convert(const snd_pcm_channel_area_t *src_areas, snd_pcm_ufr
static int snd_pcm_linear_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *params)
{
int err;
mask_t *access_mask = alloca(mask_sizeof());
mask_t *format_mask = alloca(mask_sizeof());
mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN);
mask_load(format_mask, SND_PCM_FMTBIT_LINEAR);
snd_mask_t *access_mask = alloca(snd_mask_sizeof());
snd_mask_t *format_mask = alloca(snd_mask_sizeof());
snd_mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN);
snd_mask_load(format_mask, SND_PCM_FMTBIT_LINEAR);
err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS,
access_mask);
if (err < 0)
@ -155,8 +155,8 @@ static int snd_pcm_linear_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, sn
static int snd_pcm_linear_hw_refine_sprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *sparams)
{
snd_pcm_linear_t *linear = pcm->private;
mask_t *saccess_mask = alloca(mask_sizeof());
mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
snd_mask_t *saccess_mask = alloca(snd_mask_sizeof());
snd_mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
_snd_pcm_hw_params_any(sparams);
_snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
saccess_mask);

4
src/pcm/pcm_local.h
View file

@ -332,9 +332,9 @@ void _snd_pcm_hw_param_setempty(snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var);
int _snd_pcm_hw_param_refine_interval(snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var,
const interval_t *val);
const snd_interval_t *val);
int _snd_pcm_hw_param_mask(snd_pcm_hw_params_t *params,
unsigned int var, const mask_t *mask);
unsigned int var, const snd_mask_t *mask);
int _snd_pcm_hw_param_first(snd_pcm_hw_params_t *params,
unsigned int var);
int _snd_pcm_hw_param_last(snd_pcm_hw_params_t *params,

12
src/pcm/pcm_mulaw.c
View file

@ -232,15 +232,15 @@ static int snd_pcm_mulaw_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t
{
snd_pcm_mulaw_t *mulaw = pcm->private;
int err;
mask_t *access_mask = alloca(mask_sizeof());
mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN);
snd_mask_t *access_mask = alloca(snd_mask_sizeof());
snd_mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN);
err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS,
access_mask);
if (err < 0)
return err;
if (mulaw->sformat == SND_PCM_FORMAT_MU_LAW) {
mask_t *format_mask = alloca(mask_sizeof());
mask_load(format_mask, SND_PCM_FMTBIT_LINEAR);
snd_mask_t *format_mask = alloca(snd_mask_sizeof());
snd_mask_load(format_mask, SND_PCM_FMTBIT_LINEAR);
err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_FORMAT,
format_mask);
} else {
@ -259,8 +259,8 @@ static int snd_pcm_mulaw_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t
static int snd_pcm_mulaw_hw_refine_sprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *sparams)
{
snd_pcm_mulaw_t *mulaw = pcm->private;
mask_t *saccess_mask = alloca(mask_sizeof());
mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
snd_mask_t *saccess_mask = alloca(snd_mask_sizeof());
snd_mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
_snd_pcm_hw_params_any(sparams);
_snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
saccess_mask);

42
src/pcm/pcm_multi.c
View file

@ -102,10 +102,10 @@ static int snd_pcm_multi_info(snd_pcm_t *pcm, snd_pcm_info_t *info)
static int snd_pcm_multi_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
{
snd_pcm_multi_t *multi = pcm->private;
mask_t *access_mask = alloca(mask_sizeof());
snd_mask_t *access_mask = alloca(snd_mask_sizeof());
int err;
mask_any(access_mask);
mask_reset(access_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED);
snd_mask_any(access_mask);
snd_mask_reset(access_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED);
err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS,
access_mask);
if (err < 0)
@ -123,8 +123,8 @@ static int snd_pcm_multi_hw_refine_sprepare(snd_pcm_t *pcm, int slave_idx,
{
snd_pcm_multi_t *multi = pcm->private;
snd_pcm_multi_slave_t *slave = &multi->slaves[slave_idx];
mask_t *saccess_mask = alloca(mask_sizeof());
mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
snd_mask_t *saccess_mask = alloca(snd_mask_sizeof());
snd_mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
_snd_pcm_hw_params_any(sparams);
_snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
saccess_mask);
@ -148,13 +148,13 @@ static int snd_pcm_multi_hw_refine_schange(snd_pcm_t *pcm ATTRIBUTE_UNUSED,
SND_PCM_HW_PARBIT_BUFFER_SIZE |
SND_PCM_HW_PARBIT_BUFFER_TIME |
SND_PCM_HW_PARBIT_TICK_TIME);
const mask_t *access_mask = snd_pcm_hw_param_value_mask(params, SND_PCM_HW_PARAM_ACCESS);
if (!mask_test(access_mask, SND_PCM_ACCESS_RW_INTERLEAVED) &&
!mask_test(access_mask, SND_PCM_ACCESS_RW_NONINTERLEAVED) &&
!mask_test(access_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED)) {
mask_t *saccess_mask = alloca(mask_sizeof());
mask_any(saccess_mask);
mask_reset(saccess_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED);
const snd_mask_t *access_mask = snd_pcm_hw_param_value_mask(params, SND_PCM_HW_PARAM_ACCESS);
if (!snd_mask_test(access_mask, SND_PCM_ACCESS_RW_INTERLEAVED) &&
!snd_mask_test(access_mask, SND_PCM_ACCESS_RW_NONINTERLEAVED) &&
!snd_mask_test(access_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED)) {
snd_mask_t *saccess_mask = alloca(snd_mask_sizeof());
snd_mask_any(saccess_mask);
snd_mask_reset(saccess_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED);
err = _snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
saccess_mask);
if (err < 0)
@ -181,15 +181,15 @@ static int snd_pcm_multi_hw_refine_cchange(snd_pcm_t *pcm ATTRIBUTE_UNUSED,
SND_PCM_HW_PARBIT_BUFFER_SIZE |
SND_PCM_HW_PARBIT_BUFFER_TIME |
SND_PCM_HW_PARBIT_TICK_TIME);
mask_t *access_mask = alloca(mask_sizeof());
const mask_t *saccess_mask = snd_pcm_hw_param_value_mask(sparams, SND_PCM_HW_PARAM_ACCESS);
mask_any(access_mask);
mask_reset(access_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED);
if (!mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED))
mask_reset(access_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED);
if (!mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_COMPLEX) &&
!mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED))
mask_reset(access_mask, SND_PCM_ACCESS_MMAP_COMPLEX);
snd_mask_t *access_mask = alloca(snd_mask_sizeof());
const snd_mask_t *saccess_mask = snd_pcm_hw_param_value_mask(sparams, SND_PCM_HW_PARAM_ACCESS);
snd_mask_any(access_mask);
snd_mask_reset(access_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED);
if (!snd_mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED))
snd_mask_reset(access_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED);
if (!snd_mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_COMPLEX) &&
!snd_mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED))
snd_mask_reset(access_mask, SND_PCM_ACCESS_MMAP_COMPLEX);
err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS,
access_mask);
if (err < 0)

246
src/pcm/pcm_params.c
View file

@ -20,8 +20,8 @@
*/
#include "pcm_local.h"
#define INTERVAL_INLINE
#define MASK_INLINE
#define SND_INTERVAL_INLINE
#define SND_MASK_INLINE
#include "interval.h"
#include "mask.h"
@ -37,42 +37,42 @@ static inline int hw_is_interval(int var)
var <= SND_PCM_HW_PARAM_LAST_INTERVAL;
}
static inline mask_t *hw_param_mask(snd_pcm_hw_params_t *params,
static inline snd_mask_t *hw_param_mask(snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var)
{
assert(hw_is_mask(var));
return (mask_t*)&params->masks[var - SND_PCM_HW_PARAM_FIRST_MASK];
return (snd_mask_t*)&params->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 &params->intervals[var - SND_PCM_HW_PARAM_FIRST_INTERVAL];
}
static inline const mask_t *hw_param_mask_c(const snd_pcm_hw_params_t *params,
static inline const snd_mask_t *hw_param_mask_c(const snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var)
{
return (const mask_t *)hw_param_mask((snd_pcm_hw_params_t*) params, var);
return (const snd_mask_t *)hw_param_mask((snd_pcm_hw_params_t*) params, var);
}
static inline const interval_t *hw_param_interval_c(const snd_pcm_hw_params_t *params,
static inline const snd_interval_t *hw_param_interval_c(const snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var)
{
return (const interval_t *)hw_param_interval((snd_pcm_hw_params_t*) params, var);
return (const snd_interval_t *)hw_param_interval((snd_pcm_hw_params_t*) params, var);
}
void _snd_pcm_hw_param_any(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var)
{
if (hw_is_mask(var)) {
mask_any(hw_param_mask(params, var));
snd_mask_any(hw_param_mask(params, var));
params->cmask |= 1 << var;
params->rmask |= 1 << var;
return;
}
if (hw_is_interval(var)) {
interval_any(hw_param_interval(params, var));
snd_interval_any(hw_param_interval(params, var));
params->cmask |= 1 << var;
params->rmask |= 1 << var;
return;
@ -110,20 +110,20 @@ int snd_pcm_hw_param_value(const snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var, int *dir)
{
if (hw_is_mask(var)) {
const mask_t *mask = hw_param_mask_c(params, var);
if (!mask_single(mask))
const snd_mask_t *mask = hw_param_mask_c(params, var);
if (!snd_mask_single(mask))
return -EINVAL;
if (dir)
*dir = 0;
return mask_value(mask);
return snd_mask_value(mask);
}
if (hw_is_interval(var)) {
const interval_t *i = hw_param_interval_c(params, var);
if (!interval_single(i))
const snd_interval_t *i = hw_param_interval_c(params, var);
if (!snd_interval_single(i))
return -EINVAL;
if (dir)
*dir = i->openmin;
return interval_value(i);
return snd_interval_value(i);
}
assert(0);
return -EINVAL;
@ -136,13 +136,13 @@ unsigned int snd_pcm_hw_param_value_min(const snd_pcm_hw_params_t *params,
if (hw_is_mask(var)) {
if (dir)
*dir = 0;
return mask_min(hw_param_mask_c(params, var));
return snd_mask_min(hw_param_mask_c(params, var));
}
if (hw_is_interval(var)) {
const interval_t *i = hw_param_interval_c(params, var);
const snd_interval_t *i = hw_param_interval_c(params, var);
if (dir)
*dir = i->openmin;
return interval_min(i);
return snd_interval_min(i);
}
assert(0);
return -EINVAL;
@ -155,13 +155,13 @@ unsigned int snd_pcm_hw_param_value_max(const snd_pcm_hw_params_t *params,
if (hw_is_mask(var)) {
if (dir)
*dir = 0;
return mask_max(hw_param_mask_c(params, var));
return snd_mask_max(hw_param_mask_c(params, var));
}
if (hw_is_interval(var)) {
const interval_t *i = hw_param_interval_c(params, var);
const snd_interval_t *i = hw_param_interval_c(params, var);
if (dir)
*dir = - (int) i->openmax;
return interval_max(i);
return snd_interval_max(i);
}
assert(0);
return -EINVAL;
@ -170,7 +170,7 @@ unsigned int snd_pcm_hw_param_value_max(const snd_pcm_hw_params_t *params,
/* Return the mask for field PAR.
This function can be called only for SND_PCM_HW_PARAM_ACCESS,
SND_PCM_HW_PARAM_FORMAT, SND_PCM_HW_PARAM_SUBFORMAT. */
const mask_t *snd_pcm_hw_param_value_mask(const snd_pcm_hw_params_t *params,
const snd_mask_t *snd_pcm_hw_param_value_mask(const snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var)
{
assert(hw_is_mask(var));
@ -180,7 +180,7 @@ const mask_t *snd_pcm_hw_param_value_mask(const snd_pcm_hw_params_t *params,
/* Return the interval for field PAR.
This function cannot be called for SND_PCM_HW_PARAM_ACCESS,
SND_PCM_HW_PARAM_FORMAT, SND_PCM_HW_PARAM_SUBFORMAT. */
const interval_t *snd_pcm_hw_param_value_interval(const snd_pcm_hw_params_t *params,
const snd_interval_t *snd_pcm_hw_param_value_interval(const snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var)
{
assert(hw_is_interval(var));
@ -191,11 +191,11 @@ const interval_t *snd_pcm_hw_param_value_interval(const snd_pcm_hw_params_t *par
int _snd_pcm_hw_param_refine_interval(snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var,
const interval_t *val)
const snd_interval_t *val)
{
int changed;
assert(hw_is_interval(var));
changed = interval_refine(hw_param_interval(params, var), val);
changed = snd_interval_refine(hw_param_interval(params, var), val);
if (changed) {
params->cmask |= 1 << var;
params->rmask |= 1 << var;
@ -207,11 +207,11 @@ void _snd_pcm_hw_param_setempty(snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var)
{
if (hw_is_mask(var)) {
mask_none(hw_param_mask(params, var));
snd_mask_none(hw_param_mask(params, var));
params->cmask |= 1 << var;
params->rmask |= 1 << var;
} else if (hw_is_interval(var)) {
interval_none(hw_param_interval(params, var));
snd_interval_none(hw_param_interval(params, var));
params->cmask |= 1 << var;
params->rmask |= 1 << var;
} else {
@ -224,7 +224,7 @@ int _snd_pcm_hw_param_setinteger(snd_pcm_hw_params_t *params,
{
int changed;
assert(hw_is_interval(var));
changed = interval_setinteger(hw_param_interval(params, var));
changed = snd_interval_setinteger(hw_param_interval(params, var));
if (changed) {
params->cmask |= 1 << var;
params->rmask |= 1 << var;
@ -256,9 +256,9 @@ int _snd_pcm_hw_param_first(snd_pcm_hw_params_t *params,
{
int changed;
if (hw_is_mask(var))
changed = mask_refine_first(hw_param_mask(params, var));
changed = snd_mask_refine_first(hw_param_mask(params, var));
else if (hw_is_interval(var))
changed = interval_refine_first(hw_param_interval(params, var));
changed = snd_interval_refine_first(hw_param_interval(params, var));
else {
assert(0);
return -EINVAL;
@ -294,9 +294,9 @@ int _snd_pcm_hw_param_last(snd_pcm_hw_params_t *params,
{
int changed;
if (hw_is_mask(var))
changed = mask_refine_last(hw_param_mask(params, var));
changed = snd_mask_refine_last(hw_param_mask(params, var));
else if (hw_is_interval(var))
changed = interval_refine_last(hw_param_interval(params, var));
changed = snd_interval_refine_last(hw_param_interval(params, var));
else {
assert(0);
return -EINVAL;
@ -343,9 +343,9 @@ int _snd_pcm_hw_param_min(snd_pcm_hw_params_t *params,
}
}
if (hw_is_mask(var))
changed = mask_refine_min(hw_param_mask(params, var), val + !!open);
changed = snd_mask_refine_min(hw_param_mask(params, var), val + !!open);
else if (hw_is_interval(var))
changed = interval_refine_min(hw_param_interval(params, var), val, open);
changed = snd_interval_refine_min(hw_param_interval(params, var), val, open);
else {
assert(0);
return -EINVAL;
@ -403,12 +403,12 @@ int _snd_pcm_hw_param_max(snd_pcm_hw_params_t *params,
}
if (hw_is_mask(var)) {
if (val == 0 && open) {
mask_none(hw_param_mask(params, var));
snd_mask_none(hw_param_mask(params, var));
changed = -EINVAL;
} else
changed = mask_refine_max(hw_param_mask(params, var), val - !!open);
changed = snd_mask_refine_max(hw_param_mask(params, var), val - !!open);
} else if (hw_is_interval(var))
changed = interval_refine_max(hw_param_interval(params, var), val, open);
changed = snd_interval_refine_max(hw_param_interval(params, var), val, open);
else {
assert(0);
return -EINVAL;
@ -477,16 +477,16 @@ int _snd_pcm_hw_param_minmax(snd_pcm_hw_params_t *params,
}
}
if (hw_is_mask(var)) {
mask_t *mask = hw_param_mask(params, var);
snd_mask_t *mask = hw_param_mask(params, var);
if (max == 0 && openmax) {
mask_none(mask);
snd_mask_none(mask);
changed = -EINVAL;
} else {
c1 = mask_refine_min(mask, min + !!openmin);
c1 = snd_mask_refine_min(mask, min + !!openmin);
if (c1 < 0)
changed = c1;
else {
c2 = mask_refine_max(mask, max - !!openmax);
c2 = snd_mask_refine_max(mask, max - !!openmax);
if (c2 < 0)
changed = c2;
else
@ -495,12 +495,12 @@ int _snd_pcm_hw_param_minmax(snd_pcm_hw_params_t *params,
}
}
else if (hw_is_interval(var)) {
interval_t *i = hw_param_interval(params, var);
c1 = interval_refine_min(i, min, openmin);
snd_interval_t *i = hw_param_interval(params, var);
c1 = snd_interval_refine_min(i, min, openmin);
if (c1 < 0)
changed = c1;
else {
c2 = interval_refine_max(i, max, openmax);
c2 = snd_interval_refine_max(i, max, openmax);
if (c2 < 0)
changed = c2;
else
@ -562,26 +562,26 @@ int _snd_pcm_hw_param_set(snd_pcm_hw_params_t *params,
{
int changed;
if (hw_is_mask(var)) {
mask_t *m = hw_param_mask(params, var);
snd_mask_t *m = hw_param_mask(params, var);
if (val == 0 && dir < 0) {
changed = -EINVAL;
mask_none(m);
snd_mask_none(m);
} else {
if (dir > 0)
val++;
else if (dir < 0)
val--;
changed = mask_refine_set(hw_param_mask(params, var), val);
changed = snd_mask_refine_set(hw_param_mask(params, var), val);
}
} else if (hw_is_interval(var)) {
interval_t *i = hw_param_interval(params, var);
snd_interval_t *i = hw_param_interval(params, var);
if (val == 0 && dir < 0) {
changed = -EINVAL;
interval_none(i);
snd_interval_none(i);
} else if (dir == 0)
changed = interval_refine_set(i, val);
changed = snd_interval_refine_set(i, val);
else {
interval_t t;
snd_interval_t t;
t.openmin = 1;
t.openmax = 1;
t.empty = 0;
@ -593,7 +593,7 @@ int _snd_pcm_hw_param_set(snd_pcm_hw_params_t *params,
t.min = val;
t.max = val+1;
}
changed = interval_refine(i, &t);
changed = snd_interval_refine(i, &t);
}
} else {
assert(0);
@ -637,11 +637,11 @@ int snd_pcm_hw_param_set_try(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
}
int _snd_pcm_hw_param_mask(snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var, const mask_t *val)
snd_pcm_hw_param_t var, const snd_mask_t *val)
{
int changed;
assert(hw_is_mask(var));
changed = mask_refine(hw_param_mask(params, var), val);
changed = snd_mask_refine(hw_param_mask(params, var), val);
if (changed) {
params->cmask |= 1 << var;
params->rmask |= 1 << var;
@ -657,7 +657,7 @@ int _snd_pcm_hw_param_mask(snd_pcm_hw_params_t *params,
if the configuration space is empty
*/
int snd_pcm_hw_param_mask(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var, const mask_t *val)
snd_pcm_hw_param_t var, const snd_mask_t *val)
{
int changed = _snd_pcm_hw_param_mask(params, var, val);
if (changed < 0)
@ -670,8 +670,8 @@ int snd_pcm_hw_param_mask(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
return 0;
}
int snd_pcm_hw_param_mask_try(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var, const mask_t *val)
int snd_pcm_hw_param_snd_mask_try(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var, const snd_mask_t *val)
{
snd_pcm_hw_params_t save;
int err;
@ -859,9 +859,9 @@ int snd_pcm_hw_param_empty(const snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var)
{
if (hw_is_mask(var))
return mask_empty(hw_param_mask_c(params, var));
return snd_mask_empty(hw_param_mask_c(params, var));
if (hw_is_interval(var))
return interval_empty(hw_param_interval_c(params, var));
return snd_interval_empty(hw_param_interval_c(params, var));
assert(0);
return -EINVAL;
}
@ -871,10 +871,10 @@ int snd_pcm_hw_param_always_eq(const snd_pcm_hw_params_t *params,
const snd_pcm_hw_params_t *params1)
{
if (hw_is_mask(var))
return mask_always_eq(hw_param_mask_c(params, var),
return snd_mask_always_eq(hw_param_mask_c(params, var),
hw_param_mask_c(params1, var));
if (hw_is_interval(var))
return interval_always_eq(hw_param_interval_c(params, var),
return snd_interval_always_eq(hw_param_interval_c(params, var),
hw_param_interval_c(params1, var));
assert(0);
return -EINVAL;
@ -885,10 +885,10 @@ int snd_pcm_hw_param_never_eq(const snd_pcm_hw_params_t *params,
const snd_pcm_hw_params_t *params1)
{
if (hw_is_mask(var))
return mask_never_eq(hw_param_mask_c(params, var),
return snd_mask_never_eq(hw_param_mask_c(params, var),
hw_param_mask_c(params1, var));
if (hw_is_interval(var))
return interval_never_eq(hw_param_interval_c(params, var),
return snd_interval_never_eq(hw_param_interval_c(params, var),
hw_param_interval_c(params1, var));
assert(0);
return -EINVAL;
@ -1026,12 +1026,12 @@ int snd_pcm_hw_param_test(const snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var, unsigned int val)
{
if (hw_is_mask(var)) {
const mask_t *mask = hw_param_mask_c(params, var);
return mask_test(mask, val);
const snd_mask_t *mask = hw_param_mask_c(params, var);
return snd_mask_test(mask, val);
}
if (hw_is_interval(var)) {
const interval_t *i = hw_param_interval_c(params, var);
return interval_test(i, val);
const snd_interval_t *i = hw_param_interval_c(params, var);
return snd_interval_test(i, val);
}
assert(0);
return -EINVAL;
@ -1041,12 +1041,12 @@ unsigned int snd_pcm_hw_param_count(const snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var)
{
if (hw_is_mask(var)) {
const mask_t *mask = hw_param_mask_c(params, var);
return mask_count(mask);
const snd_mask_t *mask = hw_param_mask_c(params, var);
return snd_mask_count(mask);
}
if (hw_is_interval(var)) {
const interval_t *i = hw_param_interval_c(params, var);
return interval_max(i) - interval_min(i) + 1;
const snd_interval_t *i = hw_param_interval_c(params, var);
return snd_interval_max(i) - snd_interval_min(i) + 1;
}
assert(0);
return 0;
@ -1058,13 +1058,13 @@ int _snd_pcm_hw_param_refine(snd_pcm_hw_params_t *params,
{
int changed = 0;
if (hw_is_mask(var)) {
mask_t *d = hw_param_mask(params, var);
const mask_t *s = hw_param_mask_c(src, var);
changed = mask_refine(d, s);
snd_mask_t *d = hw_param_mask(params, var);
const snd_mask_t *s = hw_param_mask_c(src, var);
changed = snd_mask_refine(d, s);
} else if (hw_is_interval(var)) {
interval_t *d = hw_param_interval(params, var);
const interval_t *s = hw_param_interval_c(src, var);
changed = interval_refine(d, s);
snd_interval_t *d = hw_param_interval(params, var);
const snd_interval_t *s = hw_param_interval_c(src, var);
changed = snd_interval_refine(d, s);
} else
assert(0);
if (changed) {
@ -1078,16 +1078,16 @@ void _snd_pcm_hw_param_copy(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var,
const snd_pcm_hw_params_t *src)
{
if (hw_is_mask(var)) {
mask_t *d = hw_param_mask(params, var);
const mask_t *s = hw_param_mask_c(src, var);
mask_copy(d, s);
snd_mask_t *d = hw_param_mask(params, var);
const snd_mask_t *s = hw_param_mask_c(src, var);
snd_mask_copy(d, s);
params->cmask |= 1 << var;
params->rmask |= 1 << var;
}
if (hw_is_interval(var)) {
interval_t *d = hw_param_interval(params, var);
const interval_t *s = hw_param_interval_c(src, var);
interval_copy(d, s);
snd_interval_t *d = hw_param_interval(params, var);
const snd_interval_t *s = hw_param_interval_c(src, var);
snd_interval_copy(d, s);
params->cmask |= 1 << var;
params->rmask |= 1 << var;
}
@ -1103,10 +1103,10 @@ void snd_pcm_hw_param_dump(const snd_pcm_hw_params_t *params,
[SND_PCM_HW_PARAM_SUBFORMAT] = snd_pcm_subformat_name,
};
if (hw_is_mask(var)) {
const mask_t *mask = hw_param_mask_c(params, var);
if (mask_empty(mask))
const snd_mask_t *mask = hw_param_mask_c(params, var);
if (snd_mask_empty(mask))
snd_output_puts(out, " NONE");
else if (mask_full(mask))
else if (snd_mask_full(mask))
snd_output_puts(out, " ALL");
else {
unsigned int k;
@ -1114,8 +1114,8 @@ void snd_pcm_hw_param_dump(const snd_pcm_hw_params_t *params,
assert(var < sizeof(funcs) / sizeof(funcs[0]));
f = funcs[var];
assert(f);
for (k = 0; k <= MASK_MAX; ++k) {
if (mask_test(mask, k)) {
for (k = 0; k <= SND_MASK_MAX; ++k) {
if (snd_mask_test(mask, k)) {
const char *s = f(k);
if (s) {
snd_output_putc(out, ' ');
@ -1127,7 +1127,7 @@ void snd_pcm_hw_param_dump(const snd_pcm_hw_params_t *params,
return;
}
if (hw_is_interval(var)) {
interval_print(hw_param_interval_c(params, var), out);
snd_interval_print(hw_param_interval_c(params, var), out);
return;
}
assert(0);
@ -1513,39 +1513,39 @@ struct _snd_pcm_hw_rule {
int snd_pcm_hw_rule_mul(snd_pcm_hw_params_t *params,
snd_pcm_hw_rule_t *rule)
{
interval_t t;
interval_mul(hw_param_interval_c(params, rule->deps[0]),
snd_interval_t t;
snd_interval_mul(hw_param_interval_c(params, rule->deps[0]),
hw_param_interval_c(params, rule->deps[1]), &t);
return interval_refine(hw_param_interval(params, rule->var), &t);
return snd_interval_refine(hw_param_interval(params, rule->var), &t);
}
int snd_pcm_hw_rule_div(snd_pcm_hw_params_t *params,
snd_pcm_hw_rule_t *rule)
{
interval_t t;
interval_div(hw_param_interval_c(params, rule->deps[0]),
snd_interval_t t;
snd_interval_div(hw_param_interval_c(params, rule->deps[0]),
hw_param_interval_c(params, rule->deps[1]), &t);
return interval_refine(hw_param_interval(params, rule->var), &t);
return snd_interval_refine(hw_param_interval(params, rule->var), &t);
}
int snd_pcm_hw_rule_muldivk(snd_pcm_hw_params_t *params,
snd_pcm_hw_rule_t *rule)
{
interval_t t;
interval_muldivk(hw_param_interval_c(params, rule->deps[0]),
snd_interval_t t;
snd_interval_muldivk(hw_param_interval_c(params, rule->deps[0]),
hw_param_interval_c(params, rule->deps[1]),
(unsigned long) rule->private, &t);
return interval_refine(hw_param_interval(params, rule->var), &t);
return snd_interval_refine(hw_param_interval(params, rule->var), &t);
}
int snd_pcm_hw_rule_mulkdiv(snd_pcm_hw_params_t *params,
snd_pcm_hw_rule_t *rule)
{
interval_t t;
interval_mulkdiv(hw_param_interval_c(params, rule->deps[0]),
snd_interval_t t;
snd_interval_mulkdiv(hw_param_interval_c(params, rule->deps[0]),
(unsigned long) rule->private,
hw_param_interval_c(params, rule->deps[1]), &t);
return interval_refine(hw_param_interval(params, rule->var), &t);
return snd_interval_refine(hw_param_interval(params, rule->var), &t);
}
int snd_pcm_hw_rule_format(snd_pcm_hw_params_t *params,
@ -1553,18 +1553,18 @@ int snd_pcm_hw_rule_format(snd_pcm_hw_params_t *params,
{
int changed = 0;
unsigned int k;
mask_t *mask = hw_param_mask(params, rule->var);
interval_t *i = hw_param_interval(params, rule->deps[0]);
snd_mask_t *mask = hw_param_mask(params, rule->var);
snd_interval_t *i = hw_param_interval(params, rule->deps[0]);
for (k = 0; k <= SND_PCM_FORMAT_LAST; ++k) {
int bits;
if (!mask_test(mask, k))
if (!snd_mask_test(mask, k))
continue;
bits = snd_pcm_format_physical_width(k);
if (bits < 0)
continue;
if (!interval_test(i, bits)) {
mask_reset(mask, k);
if (mask_empty(mask))
if (!snd_interval_test(i, bits)) {
snd_mask_reset(mask, k);
if (snd_mask_empty(mask))
return -EINVAL;
changed = 1;
}
@ -1578,14 +1578,14 @@ int snd_pcm_hw_rule_sample_bits(snd_pcm_hw_params_t *params,
{
unsigned int min, max;
unsigned int k;
interval_t *i = hw_param_interval(params, rule->var);
mask_t *mask = hw_param_mask(params, rule->deps[0]);
snd_interval_t *i = hw_param_interval(params, rule->var);
snd_mask_t *mask = hw_param_mask(params, rule->deps[0]);
int c, changed = 0;
min = UINT_MAX;
max = 0;
for (k = 0; k <= SND_PCM_FORMAT_LAST; ++k) {
int bits;
if (!mask_test(mask, k))
if (!snd_mask_test(mask, k))
continue;
bits = snd_pcm_format_physical_width(k);
if (bits < 0)
@ -1595,12 +1595,12 @@ int snd_pcm_hw_rule_sample_bits(snd_pcm_hw_params_t *params,
if (max < (unsigned)bits)
max = bits;
}
c = interval_refine_min(i, min, 0);
c = snd_interval_refine_min(i, min, 0);
if (c < 0)
return c;
if (c)
changed = 1;
c = interval_refine_max(i, max, 0);
c = snd_interval_refine_max(i, max, 0);
if (c < 0)
return c;
if (c)
@ -1752,7 +1752,7 @@ static snd_pcm_hw_rule_t refine_rules[] = {
#define RULES (sizeof(refine_rules) / sizeof(refine_rules[0]))
static mask_t refine_masks[SND_PCM_HW_PARAM_LAST_MASK - SND_PCM_HW_PARAM_FIRST_MASK + 1] = {
static snd_mask_t refine_masks[SND_PCM_HW_PARAM_LAST_MASK - SND_PCM_HW_PARAM_FIRST_MASK + 1] = {
[SND_PCM_HW_PARAM_ACCESS - SND_PCM_HW_PARAM_FIRST_MASK] = {
bits: (1 << (SND_PCM_ACCESS_LAST + 1)) - 1,
},
@ -1764,7 +1764,7 @@ static mask_t refine_masks[SND_PCM_HW_PARAM_LAST_MASK - SND_PCM_HW_PARAM_FIRST_M
},
};
static interval_t refine_intervals[SND_PCM_HW_PARAM_LAST_INTERVAL - SND_PCM_HW_PARAM_FIRST_INTERVAL + 1] = {
static snd_interval_t refine_intervals[SND_PCM_HW_PARAM_LAST_INTERVAL - SND_PCM_HW_PARAM_FIRST_INTERVAL + 1] = {
[SND_PCM_HW_PARAM_SAMPLE_BITS - SND_PCM_HW_PARAM_FIRST_INTERVAL] = {
min: 1, max: UINT_MAX,
openmin: 0, openmax: 0, integer: 1, empty: 0,
@ -1820,7 +1820,7 @@ static interval_t refine_intervals[SND_PCM_HW_PARAM_LAST_INTERVAL - SND_PCM_HW_P
int snd_pcm_hw_refine_soft(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *params)
{
unsigned int k;
interval_t *i;
snd_interval_t *i;
unsigned int rstamps[RULES];
unsigned int vstamps[SND_PCM_HW_PARAM_LAST + 1];
unsigned int stamp = 2;
@ -1833,7 +1833,7 @@ int snd_pcm_hw_refine_soft(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t
for (k = SND_PCM_HW_PARAM_FIRST_MASK; k <= SND_PCM_HW_PARAM_LAST_MASK; k++) {
if (!(params->rmask & (1 << k)))
continue;
changed = mask_refine(hw_param_mask(params, k),
changed = snd_mask_refine(hw_param_mask(params, k),
&refine_masks[k - SND_PCM_HW_PARAM_FIRST_MASK]);
if (changed)
params->cmask |= 1 << k;
@ -1844,7 +1844,7 @@ int snd_pcm_hw_refine_soft(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t
for (k = SND_PCM_HW_PARAM_FIRST_INTERVAL; k <= SND_PCM_HW_PARAM_LAST_INTERVAL; k++) {
if (!(params->rmask & (1 << k)))
continue;
changed = interval_refine(hw_param_interval(params, k),
changed = snd_interval_refine(hw_param_interval(params, k),
&refine_intervals[k - SND_PCM_HW_PARAM_FIRST_INTERVAL]);
if (changed)
params->cmask |= 1 << k;
@ -1902,14 +1902,14 @@ int snd_pcm_hw_refine_soft(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t
} while (again);
if (!params->msbits) {
i = hw_param_interval(params, SND_PCM_HW_PARAM_SAMPLE_BITS);
if (interval_single(i))
params->msbits = interval_value(i);
if (snd_interval_single(i))
params->msbits = snd_interval_value(i);
}
if (!params->rate_den) {
i = hw_param_interval(params, SND_PCM_HW_PARAM_RATE);
if (interval_single(i)) {
params->rate_num = interval_value(i);
if (snd_interval_single(i)) {
params->rate_num = snd_interval_value(i);
params->rate_den = 1;
}
}

68
src/pcm/pcm_plug.c
View file

@ -120,14 +120,14 @@ static unsigned int nonlinear_preferred_formats[] = {
SND_PCM_FORMAT_IMA_ADPCM,
};
static int snd_pcm_plug_slave_format(int format, const mask_t *format_mask)
static int snd_pcm_plug_slave_format(int format, const snd_mask_t *format_mask)
{
int w, u, e, wid, w1, dw;
mask_t *lin = alloca(mask_sizeof());
if (mask_test(format_mask, format))
snd_mask_t *lin = alloca(snd_mask_sizeof());
if (snd_mask_test(format_mask, format))
return format;
mask_load(lin, SND_PCM_FMTBIT_LINEAR);
if (!mask_test(lin, format)) {
snd_mask_load(lin, SND_PCM_FMTBIT_LINEAR);
if (!snd_mask_test(lin, format)) {
unsigned int i;
switch (format) {
case SND_PCM_FORMAT_MU_LAW:
@ -135,7 +135,7 @@ static int snd_pcm_plug_slave_format(int format, const mask_t *format_mask)
case SND_PCM_FORMAT_IMA_ADPCM:
for (i = 0; i < sizeof(linear_preferred_formats) / sizeof(linear_preferred_formats[0]); ++i) {
unsigned int f = linear_preferred_formats[i];
if (mask_test(format_mask, f))
if (snd_mask_test(format_mask, f))
return f;
}
/* Fall through */
@ -144,12 +144,12 @@ static int snd_pcm_plug_slave_format(int format, const mask_t *format_mask)
}
}
mask_intersect(lin, format_mask);
if (mask_empty(lin)) {
snd_mask_intersect(lin, format_mask);
if (snd_mask_empty(lin)) {
unsigned int i;
for (i = 0; i < sizeof(nonlinear_preferred_formats) / sizeof(nonlinear_preferred_formats[0]); ++i) {
unsigned int f = nonlinear_preferred_formats[i];
if (mask_test(format_mask, f))
if (snd_mask_test(format_mask, f))
return f;
}
return -EINVAL;
@ -166,7 +166,7 @@ static int snd_pcm_plug_slave_format(int format, const mask_t *format_mask)
for (sgn = 0; sgn < 2; ++sgn) {
int f;
f = snd_pcm_build_linear_format(w1, u1, e1);
if (f >= 0 && mask_test(format_mask, f))
if (f >= 0 && snd_mask_test(format_mask, f))
return f;
u1 = !u1;
}
@ -419,12 +419,12 @@ static int snd_pcm_plug_hw_refine_schange(snd_pcm_t *pcm, snd_pcm_hw_params_t *p
snd_pcm_t *slave = plug->req_slave;
unsigned int links = (SND_PCM_HW_PARBIT_PERIOD_TIME |
SND_PCM_HW_PARBIT_TICK_TIME);
const mask_t *format_mask, *sformat_mask;
mask_t *sfmt_mask = alloca(mask_sizeof());
const snd_mask_t *format_mask, *sformat_mask;
snd_mask_t *sfmt_mask = alloca(snd_mask_sizeof());
int err;
unsigned int format;
interval_t t, buffer_size;
const interval_t *srate, *crate;
snd_interval_t t, buffer_size;
const snd_interval_t *srate, *crate;
snd_pcm_hw_param_refine_near(slave, sparams, SND_PCM_HW_PARAM_RATE,
params);
snd_pcm_hw_param_refine_near(slave, sparams, SND_PCM_HW_PARAM_CHANNELS,
@ -433,19 +433,19 @@ static int snd_pcm_plug_hw_refine_schange(snd_pcm_t *pcm, snd_pcm_hw_params_t *p
SND_PCM_HW_PARAM_FORMAT);
sformat_mask = snd_pcm_hw_param_value_mask(sparams,
SND_PCM_HW_PARAM_FORMAT);
mask_none(sfmt_mask);
snd_mask_none(sfmt_mask);
for (format = 0; format <= SND_PCM_FORMAT_LAST; format++) {
int f;
if (!mask_test(format_mask, format))
if (!snd_mask_test(format_mask, format))
continue;
if (mask_test(sformat_mask, format))
if (snd_mask_test(sformat_mask, format))
f = format;
else {
f = snd_pcm_plug_slave_format(format, sformat_mask);
if (f < 0)
continue;
}
mask_set(sfmt_mask, f);
snd_mask_set(sfmt_mask, f);
}
err = snd_pcm_hw_param_mask(slave, sparams,
@ -456,16 +456,16 @@ static int snd_pcm_plug_hw_refine_schange(snd_pcm_t *pcm, snd_pcm_hw_params_t *p
snd_pcm_hw_param_never_eq(params, SND_PCM_HW_PARAM_CHANNELS, sparams) ||
snd_pcm_hw_param_never_eq(params, SND_PCM_HW_PARAM_RATE, sparams) ||
snd_pcm_hw_param_never_eq(params, SND_PCM_HW_PARAM_ACCESS, sparams)) {
mask_t *access_mask = alloca(mask_sizeof());
mask_load(access_mask, SND_PCM_ACCBIT_MMAP);
snd_mask_t *access_mask = alloca(snd_mask_sizeof());
snd_mask_load(access_mask, SND_PCM_ACCBIT_MMAP);
_snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
access_mask);
}
interval_copy(&buffer_size, snd_pcm_hw_param_value_interval(params, SND_PCM_HW_PARAM_BUFFER_SIZE));
interval_unfloor(&buffer_size);
snd_interval_copy(&buffer_size, snd_pcm_hw_param_value_interval(params, SND_PCM_HW_PARAM_BUFFER_SIZE));
snd_interval_unfloor(&buffer_size);
crate = snd_pcm_hw_param_value_interval(params, SND_PCM_HW_PARAM_RATE);
srate = snd_pcm_hw_param_value_interval(sparams, SND_PCM_HW_PARAM_RATE);
interval_muldiv(&buffer_size, srate, crate, &t);
snd_interval_muldiv(&buffer_size, srate, crate, &t);
err = _snd_pcm_hw_param_refine_interval(sparams, SND_PCM_HW_PARAM_BUFFER_SIZE, &t);
if (err < 0)
return err;
@ -481,32 +481,32 @@ static int snd_pcm_plug_hw_refine_cchange(snd_pcm_t *pcm ATTRIBUTE_UNUSED,
{
unsigned int links = (SND_PCM_HW_PARBIT_PERIOD_TIME |
SND_PCM_HW_PARBIT_TICK_TIME);
const mask_t *format_mask, *sformat_mask;
mask_t *fmt_mask = alloca(mask_sizeof());
const snd_mask_t *format_mask, *sformat_mask;
snd_mask_t *fmt_mask = alloca(snd_mask_sizeof());
int err;
unsigned int format;
interval_t t;
const interval_t *sbuffer_size;
const interval_t *srate, *crate;
snd_interval_t t;
const snd_interval_t *sbuffer_size;
const snd_interval_t *srate, *crate;
unsigned int rate_min, srate_min;
int rate_mindir, srate_mindir;
format_mask = snd_pcm_hw_param_value_mask(params,
SND_PCM_HW_PARAM_FORMAT);
sformat_mask = snd_pcm_hw_param_value_mask(sparams,
SND_PCM_HW_PARAM_FORMAT);
mask_none(fmt_mask);
snd_mask_none(fmt_mask);
for (format = 0; format <= SND_PCM_FORMAT_LAST; format++) {
int f;
if (!mask_test(format_mask, format))
if (!snd_mask_test(format_mask, format))
continue;
if (mask_test(sformat_mask, format))
if (snd_mask_test(sformat_mask, format))
f = format;
else {
f = snd_pcm_plug_slave_format(format, sformat_mask);
if (f < 0)
continue;
}
mask_set(fmt_mask, format);
snd_mask_set(fmt_mask, format);
}
err = _snd_pcm_hw_param_mask(params,
@ -526,8 +526,8 @@ static int snd_pcm_plug_hw_refine_cchange(snd_pcm_t *pcm ATTRIBUTE_UNUSED,
sbuffer_size = snd_pcm_hw_param_value_interval(sparams, SND_PCM_HW_PARAM_BUFFER_SIZE);
crate = snd_pcm_hw_param_value_interval(params, SND_PCM_HW_PARAM_RATE);
srate = snd_pcm_hw_param_value_interval(sparams, SND_PCM_HW_PARAM_RATE);
interval_muldiv(sbuffer_size, crate, srate, &t);
interval_floor(&t);
snd_interval_muldiv(sbuffer_size, crate, srate, &t);
snd_interval_floor(&t);
err = _snd_pcm_hw_param_refine_interval(params, SND_PCM_HW_PARAM_BUFFER_SIZE, &t);
if (err < 0)
return err;

32
src/pcm/pcm_rate.c
View file

@ -225,10 +225,10 @@ snd_pcm_uframes_t snd_pcm_rate_shrink(const snd_pcm_channel_area_t *src_areas,
static int snd_pcm_rate_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *params)
{
int err;
mask_t *access_mask = alloca(mask_sizeof());
mask_t *format_mask = alloca(mask_sizeof());
mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN);
mask_load(format_mask, SND_PCM_FMTBIT_LINEAR);
snd_mask_t *access_mask = alloca(snd_mask_sizeof());
snd_mask_t *format_mask = alloca(snd_mask_sizeof());
snd_mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN);
snd_mask_load(format_mask, SND_PCM_FMTBIT_LINEAR);
err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS,
access_mask);
if (err < 0)
@ -256,8 +256,8 @@ static int snd_pcm_rate_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_
static int snd_pcm_rate_hw_refine_sprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *sparams)
{
snd_pcm_rate_t *rate = pcm->private;
mask_t *saccess_mask = alloca(mask_sizeof());
mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
snd_mask_t *saccess_mask = alloca(snd_mask_sizeof());
snd_mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
_snd_pcm_hw_params_any(sparams);
_snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
saccess_mask);
@ -276,8 +276,8 @@ static int snd_pcm_rate_hw_refine_schange(snd_pcm_t *pcm, snd_pcm_hw_params_t *p
snd_pcm_hw_params_t *sparams)
{
snd_pcm_rate_t *rate = pcm->private;
interval_t t, buffer_size;
const interval_t *srate, *crate;
snd_interval_t t, buffer_size;
const snd_interval_t *srate, *crate;
int err;
unsigned int links = (SND_PCM_HW_PARBIT_CHANNELS |
SND_PCM_HW_PARBIT_PERIOD_TIME |
@ -287,11 +287,11 @@ static int snd_pcm_rate_hw_refine_schange(snd_pcm_t *pcm, snd_pcm_hw_params_t *p
SND_PCM_HW_PARBIT_SUBFORMAT |
SND_PCM_HW_PARBIT_SAMPLE_BITS |
SND_PCM_HW_PARBIT_FRAME_BITS);
interval_copy(&buffer_size, snd_pcm_hw_param_value_interval(params, SND_PCM_HW_PARAM_BUFFER_SIZE));
interval_unfloor(&buffer_size);
snd_interval_copy(&buffer_size, snd_pcm_hw_param_value_interval(params, SND_PCM_HW_PARAM_BUFFER_SIZE));
snd_interval_unfloor(&buffer_size);
crate = snd_pcm_hw_param_value_interval(params, SND_PCM_HW_PARAM_RATE);
srate = snd_pcm_hw_param_value_interval(sparams, SND_PCM_HW_PARAM_RATE);
interval_muldiv(&buffer_size, srate, crate, &t);
snd_interval_muldiv(&buffer_size, srate, crate, &t);
err = _snd_pcm_hw_param_refine_interval(sparams, SND_PCM_HW_PARAM_BUFFER_SIZE, &t);
if (err < 0)
return err;
@ -305,9 +305,9 @@ static int snd_pcm_rate_hw_refine_cchange(snd_pcm_t *pcm, snd_pcm_hw_params_t *p
snd_pcm_hw_params_t *sparams)
{
snd_pcm_rate_t *rate = pcm->private;
interval_t t;
const interval_t *sbuffer_size;
const interval_t *srate, *crate;
snd_interval_t t;
const snd_interval_t *sbuffer_size;
const snd_interval_t *srate, *crate;
int err;
unsigned int links = (SND_PCM_HW_PARBIT_CHANNELS |
SND_PCM_HW_PARBIT_PERIOD_TIME |
@ -320,8 +320,8 @@ static int snd_pcm_rate_hw_refine_cchange(snd_pcm_t *pcm, snd_pcm_hw_params_t *p
sbuffer_size = snd_pcm_hw_param_value_interval(sparams, SND_PCM_HW_PARAM_BUFFER_SIZE);
crate = snd_pcm_hw_param_value_interval(params, SND_PCM_HW_PARAM_RATE);
srate = snd_pcm_hw_param_value_interval(sparams, SND_PCM_HW_PARAM_RATE);
interval_muldiv(sbuffer_size, crate, srate, &t);
interval_floor(&t);
snd_interval_muldiv(sbuffer_size, crate, srate, &t);
snd_interval_floor(&t);
err = _snd_pcm_hw_param_refine_interval(params, SND_PCM_HW_PARAM_BUFFER_SIZE, &t);
if (err < 0)
return err;

12
src/pcm/pcm_route.c
View file

@ -428,10 +428,10 @@ static int snd_pcm_route_close(snd_pcm_t *pcm)
static int snd_pcm_route_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *params)
{
int err;
mask_t *access_mask = alloca(mask_sizeof());
mask_t *format_mask = alloca(mask_sizeof());
mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN);
mask_load(format_mask, SND_PCM_FMTBIT_LINEAR);
snd_mask_t *access_mask = alloca(snd_mask_sizeof());
snd_mask_t *format_mask = alloca(snd_mask_sizeof());
snd_mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN);
snd_mask_load(format_mask, SND_PCM_FMTBIT_LINEAR);
err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS,
access_mask);
if (err < 0)
@ -454,8 +454,8 @@ static int snd_pcm_route_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd
static int snd_pcm_route_hw_refine_sprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *sparams)
{
snd_pcm_route_t *route = pcm->private;
mask_t *saccess_mask = alloca(mask_sizeof());
mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
snd_mask_t *saccess_mask = alloca(snd_mask_sizeof());
snd_mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
_snd_pcm_hw_params_any(sparams);
_snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
saccess_mask);

42
src/pcm/pcm_share.c
View file

@ -460,10 +460,10 @@ static int snd_pcm_share_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t
{
snd_pcm_share_t *share = pcm->private;
snd_pcm_share_slave_t *slave = share->slave;
mask_t *access_mask = alloca(mask_sizeof());
snd_mask_t *access_mask = alloca(snd_mask_sizeof());
int err;
mask_any(access_mask);
mask_reset(access_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED);
snd_mask_any(access_mask);
snd_mask_reset(access_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED);
err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS,
access_mask);
if (err < 0)
@ -493,8 +493,8 @@ static int snd_pcm_share_hw_refine_sprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t
{
snd_pcm_share_t *share = pcm->private;
snd_pcm_share_slave_t *slave = share->slave;
mask_t *saccess_mask = alloca(mask_sizeof());
mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
snd_mask_t *saccess_mask = alloca(snd_mask_sizeof());
snd_mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
_snd_pcm_hw_params_any(sparams);
_snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
saccess_mask);
@ -516,13 +516,13 @@ static int snd_pcm_share_hw_refine_schange(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_
SND_PCM_HW_PARBIT_BUFFER_TIME |
SND_PCM_HW_PARBIT_PERIODS |
SND_PCM_HW_PARBIT_TICK_TIME);
const mask_t *access_mask = snd_pcm_hw_param_value_mask(params, SND_PCM_HW_PARAM_ACCESS);
if (!mask_test(access_mask, SND_PCM_ACCESS_RW_INTERLEAVED) &&
!mask_test(access_mask, SND_PCM_ACCESS_RW_NONINTERLEAVED) &&
!mask_test(access_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED)) {
mask_t *saccess_mask = alloca(mask_sizeof());
mask_any(saccess_mask);
mask_reset(saccess_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED);
const snd_mask_t *access_mask = snd_pcm_hw_param_value_mask(params, SND_PCM_HW_PARAM_ACCESS);
if (!snd_mask_test(access_mask, SND_PCM_ACCESS_RW_INTERLEAVED) &&
!snd_mask_test(access_mask, SND_PCM_ACCESS_RW_NONINTERLEAVED) &&
!snd_mask_test(access_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED)) {
snd_mask_t *saccess_mask = alloca(snd_mask_sizeof());
snd_mask_any(saccess_mask);
snd_mask_reset(saccess_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED);
err = _snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
saccess_mask);
if (err < 0)
@ -547,15 +547,15 @@ static int snd_pcm_share_hw_refine_cchange(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_
SND_PCM_HW_PARBIT_BUFFER_TIME |
SND_PCM_HW_PARBIT_PERIODS |
SND_PCM_HW_PARBIT_TICK_TIME);
mask_t *access_mask = alloca(mask_sizeof());
const mask_t *saccess_mask = snd_pcm_hw_param_value_mask(sparams, SND_PCM_HW_PARAM_ACCESS);
mask_any(access_mask);
mask_reset(access_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED);
if (!mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED))
mask_reset(access_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED);
if (!mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_COMPLEX) &&
!mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED))
mask_reset(access_mask, SND_PCM_ACCESS_MMAP_COMPLEX);
snd_mask_t *access_mask = alloca(snd_mask_sizeof());
const snd_mask_t *saccess_mask = snd_pcm_hw_param_value_mask(sparams, SND_PCM_HW_PARAM_ACCESS);
snd_mask_any(access_mask);
snd_mask_reset(access_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED);
if (!snd_mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED))
snd_mask_reset(access_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED);
if (!snd_mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_COMPLEX) &&
!snd_mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED))
snd_mask_reset(access_mask, SND_PCM_ACCESS_MMAP_COMPLEX);
err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS,
access_mask);
if (err < 0)

18
src/pcm/pcm_shm.c
View file

@ -162,8 +162,8 @@ static int snd_pcm_shm_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_p
static int snd_pcm_shm_hw_refine_sprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *sparams)
{
mask_t *saccess_mask = alloca(mask_sizeof());
mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
snd_mask_t *saccess_mask = alloca(snd_mask_sizeof());
snd_mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
_snd_pcm_hw_params_any(sparams);
_snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
saccess_mask);
@ -175,9 +175,9 @@ static int snd_pcm_shm_hw_refine_schange(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pc
{
int err;
unsigned int links = ~SND_PCM_HW_PARBIT_ACCESS;
const mask_t *access_mask = snd_pcm_hw_param_value_mask(params, SND_PCM_HW_PARAM_ACCESS);
if (!mask_test(access_mask, SND_PCM_ACCESS_RW_INTERLEAVED) &&
!mask_test(access_mask, SND_PCM_ACCESS_RW_NONINTERLEAVED)) {
const snd_mask_t *access_mask = snd_pcm_hw_param_value_mask(params, SND_PCM_HW_PARAM_ACCESS);
if (!snd_mask_test(access_mask, SND_PCM_ACCESS_RW_INTERLEAVED) &&
!snd_mask_test(access_mask, SND_PCM_ACCESS_RW_NONINTERLEAVED)) {
err = _snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
access_mask);
if (err < 0)
@ -194,10 +194,10 @@ static int snd_pcm_shm_hw_refine_cchange(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pc
{
int err;
unsigned int links = ~SND_PCM_HW_PARBIT_ACCESS;
mask_t *access_mask = alloca(mask_sizeof());
mask_copy(access_mask, snd_pcm_hw_param_value_mask(sparams, SND_PCM_HW_PARAM_ACCESS));
mask_set(access_mask, SND_PCM_ACCESS_RW_INTERLEAVED);
mask_set(access_mask, SND_PCM_ACCESS_RW_NONINTERLEAVED);
snd_mask_t *access_mask = alloca(snd_mask_sizeof());
snd_mask_copy(access_mask, snd_pcm_hw_param_value_mask(sparams, SND_PCM_HW_PARAM_ACCESS));
snd_mask_set(access_mask, SND_PCM_ACCESS_RW_INTERLEAVED);
snd_mask_set(access_mask, SND_PCM_ACCESS_RW_NONINTERLEAVED);
err = _snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
access_mask);
if (err < 0)