/** CTL element type */
typedef enum _snd_ctl_elem_type {
/** Invalid type */
- SND_CTL_ELEM_TYPE_NONE = SNDRV_CTL_ELEM_TYPE_NONE,
+ SND_CTL_ELEM_TYPE_NONE = 0,
/** Boolean contents */
- SND_CTL_ELEM_TYPE_BOOLEAN = SNDRV_CTL_ELEM_TYPE_BOOLEAN,
+ SND_CTL_ELEM_TYPE_BOOLEAN,
/** Integer contents */
- SND_CTL_ELEM_TYPE_INTEGER = SNDRV_CTL_ELEM_TYPE_INTEGER,
+ SND_CTL_ELEM_TYPE_INTEGER,
/** Enumerated contents */
- SND_CTL_ELEM_TYPE_ENUMERATED = SNDRV_CTL_ELEM_TYPE_ENUMERATED,
+ SND_CTL_ELEM_TYPE_ENUMERATED,
/** Bytes contents */
- SND_CTL_ELEM_TYPE_BYTES = SNDRV_CTL_ELEM_TYPE_BYTES,
+ SND_CTL_ELEM_TYPE_BYTES,
/** IEC958 (S/PDIF) setting content */
- SND_CTL_ELEM_TYPE_IEC958 = SNDRV_CTL_ELEM_TYPE_IEC958,
- SND_CTL_ELEM_TYPE_LAST = SNDRV_CTL_ELEM_TYPE_LAST,
+ SND_CTL_ELEM_TYPE_IEC958,
+ SND_CTL_ELEM_TYPE_LAST = SND_CTL_ELEM_TYPE_IEC958,
} snd_ctl_elem_type_t;
/** CTL related interface */
typedef enum _snd_ctl_elem_iface {
/** Card level */
- SND_CTL_ELEM_IFACE_CARD = SNDRV_CTL_ELEM_IFACE_CARD,
+ SND_CTL_ELEM_IFACE_CARD = 0,
/** Hardware dependent device */
- SND_CTL_ELEM_IFACE_HWDEP = SNDRV_CTL_ELEM_IFACE_HWDEP,
+ SND_CTL_ELEM_IFACE_HWDEP,
/** Mixer */
- SND_CTL_ELEM_IFACE_MIXER = SNDRV_CTL_ELEM_IFACE_MIXER,
+ SND_CTL_ELEM_IFACE_MIXER,
/** PCM */
- SND_CTL_ELEM_IFACE_PCM = SNDRV_CTL_ELEM_IFACE_PCM,
+ SND_CTL_ELEM_IFACE_PCM,
/** RawMidi */
- SND_CTL_ELEM_IFACE_RAWMIDI = SNDRV_CTL_ELEM_IFACE_RAWMIDI,
+ SND_CTL_ELEM_IFACE_RAWMIDI,
/** Timer */
- SND_CTL_ELEM_IFACE_TIMER = SNDRV_CTL_ELEM_IFACE_TIMER,
+ SND_CTL_ELEM_IFACE_TIMER,
/** Sequencer */
- SND_CTL_ELEM_IFACE_SEQUENCER = SNDRV_CTL_ELEM_IFACE_SEQUENCER,
- SND_CTL_ELEM_IFACE_LAST = SNDRV_CTL_ELEM_IFACE_LAST,
+ SND_CTL_ELEM_IFACE_SEQUENCER,
+ SND_CTL_ELEM_IFACE_LAST = SND_CTL_ELEM_IFACE_SEQUENCER,
} snd_ctl_elem_iface_t;
/** Event class */
typedef enum _snd_ctl_event_type {
/** Elements related event */
- SND_CTL_EVENT_ELEM = SNDRV_CTL_EVENT_ELEM,
- SND_CTL_EVENT_LAST = SNDRV_CTL_EVENT_LAST,
+ SND_CTL_EVENT_ELEM = 0,
+ SND_CTL_EVENT_LAST = SND_CTL_EVENT_ELEM,
}snd_ctl_event_type_t;
/** Element has been removed (Warning: test this first and if set don't
- * test the other masks) \hideinitializer */
-#define SND_CTL_EVENT_MASK_REMOVE SNDRV_CTL_EVENT_MASK_REMOVE
-/** Element has been added \hideinitializer */
-#define SND_CTL_EVENT_MASK_ADD SNDRV_CTL_EVENT_MASK_ADD
-/** Element info has been changed \hideinitializer */
-#define SND_CTL_EVENT_MASK_INFO SNDRV_CTL_EVENT_MASK_INFO
+ * test the other masks) \hideinitializer */
+#define SND_CTL_EVENT_MASK_REMOVE (~0U)
/** Element value has been changed \hideinitializer */
-#define SND_CTL_EVENT_MASK_VALUE SNDRV_CTL_EVENT_MASK_VALUE
-
+#define SND_CTL_EVENT_MASK_VALUE (1<<0)
+/** Element info has been changed \hideinitializer */
+#define SND_CTL_EVENT_MASK_INFO (1<<1)
+/** Element has been added \hideinitializer */
+#define SND_CTL_EVENT_MASK_ADD (1<<2)
+
+/** CTL name helper */
+#define SND_CTL_NAME_NONE ""
+/** CTL name helper */
+#define SND_CTL_NAME_PLAYBACK "Playback "
+/** CTL name helper */
+#define SND_CTL_NAME_CAPTURE "Capture "
+
+/** CTL name helper */
+#define SND_CTL_NAME_IEC958_NONE ""
+/** CTL name helper */
+#define SND_CTL_NAME_IEC958_SWITCH "Switch"
+/** CTL name helper */
+#define SND_CTL_NAME_IEC958_VOLUME "Volume"
+/** CTL name helper */
+#define SND_CTL_NAME_IEC958_DEFAULT "Default"
+/** CTL name helper */
+#define SND_CTL_NAME_IEC958_MASK "Mask"
+/** CTL name helper */
+#define SND_CTL_NAME_IEC958_CON_MASK "Con Mask"
+/** CTL name helper */
+#define SND_CTL_NAME_IEC958_PRO_MASK "Pro Mask"
+/** CTL name helper */
+#define SND_CTL_NAME_IEC958_PCM_STREAM "PCM Stream"
/** Element name for IEC958 (S/PDIF) */
-#define SND_CTL_NAME_IEC958 SNDRV_CTL_NAME_IEC958
+#define SND_CTL_NAME_IEC958(expl,direction,what) "IEC958 " expl SND_CTL_NAME_##direction SND_CTL_NAME_IEC958_##what
+
/** CTL type */
typedef enum _snd_ctl_type {
* \{
*/
-#ifdef SNDRV_LITTLE_ENDIAN
-#define SND_LITTLE_ENDIAN SNDRV_LITTLE_ENDIAN
-#endif
-
-#ifdef SNDRV_BIG_ENDIAN
-#define SND_BIG_ENDIAN SNDRV_BIG_ENDIAN
-#endif
-
-/** \} */
-
/** helper macro for SND_DLSYM_BUILD_VERSION */
#define __SND_DLSYM_VERSION(name, version) _ ## name ## version
/** build version for versioned dynamic symbol */
int snd_async_del_handler(snd_async_handler_t *handler);
int snd_async_handler_get_fd(snd_async_handler_t *handler);
void *snd_async_handler_get_callback_private(snd_async_handler_t *handler);
+
+/** \} */
+
#ifndef __ASOUNDLIB_H
#define __ASOUNDLIB_H
-#include <sound/asound.h>
#include <sound/asoundef.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <assert.h>
+#include <endian.h>
#include <sys/poll.h>
#include <errno.h>
/** HwDep interface */
typedef enum _snd_hwdep_iface {
- SND_HWDEP_IFACE_OPL2 = SNDRV_HWDEP_IFACE_OPL2, /**< OPL2 raw driver */
- SND_HWDEP_IFACE_OPL3 = SNDRV_HWDEP_IFACE_OPL3, /**< OPL3 raw driver */
- SND_HWDEP_IFACE_OPL4 = SNDRV_HWDEP_IFACE_OPL4, /**< OPL4 raw driver */
- SND_HWDEP_IFACE_SB16CSP = SNDRV_HWDEP_IFACE_SB16CSP, /**< SB16CSP driver */
- SND_HWDEP_IFACE_EMU10K1 = SNDRV_HWDEP_IFACE_EMU10K1, /**< EMU10K1 driver */
- SND_HWDEP_IFACE_YSS225 = SNDRV_HWDEP_IFACE_YSS225, /**< YSS225 driver */
- SND_HWDEP_IFACE_ICS2115 = SNDRV_HWDEP_IFACE_ICS2115, /**< ICS2115 driver */
- SND_HWDEP_IFACE_LAST = SNDRV_HWDEP_IFACE_LAST, /**< last know hwdep interface */
+ SND_HWDEP_IFACE_OPL2 = 0, /**< OPL2 raw driver */
+ SND_HWDEP_IFACE_OPL3, /**< OPL3 raw driver */
+ SND_HWDEP_IFACE_OPL4, /**< OPL4 raw driver */
+ SND_HWDEP_IFACE_SB16CSP, /**< SB16CSP driver */
+ SND_HWDEP_IFACE_EMU10K1, /**< EMU10K1 driver */
+ SND_HWDEP_IFACE_YSS225, /**< YSS225 driver */
+ SND_HWDEP_IFACE_ICS2115, /**< ICS2115 driver */
+ SND_HWDEP_IFACE_LAST = SND_HWDEP_IFACE_ICS2115, /**< last know hwdep interface */
} snd_hwdep_iface_t;
/** open for reading */
*/
/** instrument types */
-#define SND_SEQ_INSTR_ATYPE_DATA SNDRV_SEQ_INSTR_ATYPE_DATA /**< instrument data */
-#define SND_SEQ_INSTR_ATYPE_ALIAS SNDRV_SEQ_INSTR_ATYPE_ALIAS /**< instrument alias */
+#define SND_SEQ_INSTR_ATYPE_DATA 0 /**< instrument data */
+#define SND_SEQ_INSTR_ATYPE_ALIAS 1 /**< instrument alias */
/** instrument ASCII identifiers */
-#define SND_SEQ_INSTR_ID_DLS1 SNDRV_SEQ_INSTR_ID_DLS1 /**< DLS1 */
-#define SND_SEQ_INSTR_ID_DLS2 SNDRV_SEQ_INSTR_ID_DLS2 /**< DLS2 */
-#define SND_SEQ_INSTR_ID_SIMPLE SNDRV_SEQ_INSTR_ID_SIMPLE /**< Simple Wave */
-#define SND_SEQ_INSTR_ID_SOUNDFONT SNDRV_SEQ_INSTR_ID_SOUNDFONT /**< SoundFont */
-#define SND_SEQ_INSTR_ID_GUS_PATCH SNDRV_SEQ_INSTR_ID_GUS_PATCH /**< Gravis Patch */
-#define SND_SEQ_INSTR_ID_INTERWAVE SNDRV_SEQ_INSTR_ID_INTERWAVE /**< InterWave FFFF */
-#define SND_SEQ_INSTR_ID_OPL2_3 SNDRV_SEQ_INSTR_ID_OPL2_3 /**< OPL2/3 FM */
-#define SND_SEQ_INSTR_ID_OPL4 SNDRV_SEQ_INSTR_ID_OPL4 /**< OPL4 */
+#define SND_SEQ_INSTR_ID_DLS1 "DLS1" /**< DLS1 */
+#define SND_SEQ_INSTR_ID_DLS2 "DLS2" /**< DLS2 */
+#define SND_SEQ_INSTR_ID_SIMPLE "Simple Wave" /**< Simple Wave */
+#define SND_SEQ_INSTR_ID_SOUNDFONT "SoundFont" /**< SoundFont */
+#define SND_SEQ_INSTR_ID_GUS_PATCH "GUS Patch" /**< Gravis Patch */
+#define SND_SEQ_INSTR_ID_INTERWAVE "Interwave FFFF" /**< InterWave FFFF */
+#define SND_SEQ_INSTR_ID_OPL2_3 "OPL2/3 FM" /**< OPL2/3 FM */
+#define SND_SEQ_INSTR_ID_OPL4 "OPL4" /**< OPL4 */
/** instrument types */
-#define SND_SEQ_INSTR_TYPE0_DLS1 SNDRV_SEQ_INSTR_TYPE0_DLS1 /**< MIDI DLS v1 */
-#define SND_SEQ_INSTR_TYPE0_DLS2 SNDRV_SEQ_INSTR_TYPE0_DLS2 /**< MIDI DLS v2 */
-#define SND_SEQ_INSTR_TYPE1_SIMPLE SNDRV_SEQ_INSTR_TYPE1_SIMPLE /**< Simple Wave */
-#define SND_SEQ_INSTR_TYPE1_SOUNDFONT SNDRV_SEQ_INSTR_TYPE1_SOUNDFONT /**< EMU SoundFont */
-#define SND_SEQ_INSTR_TYPE1_GUS_PATCH SNDRV_SEQ_INSTR_TYPE1_GUS_PATCH /**< Gravis UltraSound Patch */
-#define SND_SEQ_INSTR_TYPE1_INTERWAVE SNDRV_SEQ_INSTR_TYPE1_INTERWAVE /**< InterWave FFFF */
-#define SND_SEQ_INSTR_TYPE2_OPL2_3 SNDRV_SEQ_INSTR_TYPE2_OPL2_3 /**< Yamaha OPL2/3 FM */
-#define SND_SEQ_INSTR_TYPE2_OPL4 SNDRV_SEQ_INSTR_TYPE2_OPL4 /**< Yamaha OPL4 */
+#define SND_SEQ_INSTR_TYPE0_DLS1 (1<<0) /**< MIDI DLS v1 */
+#define SND_SEQ_INSTR_TYPE0_DLS2 (1<<1) /**< MIDI DLS v2 */
+#define SND_SEQ_INSTR_TYPE1_SIMPLE (1<<0) /**< Simple Wave */
+#define SND_SEQ_INSTR_TYPE1_SOUNDFONT (1<<1) /**< EMU SoundFont */
+#define SND_SEQ_INSTR_TYPE1_GUS_PATCH (1<<2) /**< Gravis UltraSound Patch */
+#define SND_SEQ_INSTR_TYPE1_INTERWAVE (1<<3) /**< InterWave FFFF */
+#define SND_SEQ_INSTR_TYPE2_OPL2_3 (1<<0) /**< Yamaha OPL2/3 FM */
+#define SND_SEQ_INSTR_TYPE2_OPL4 (1<<1) /**< Yamaha OPL4 */
/** put commands */
-#define SND_SEQ_INSTR_PUT_CMD_CREATE SNDRV_SEQ_INSTR_PUT_CMD_CREATE /**< create a new layer */
-#define SND_SEQ_INSTR_PUT_CMD_REPLACE SNDRV_SEQ_INSTR_PUT_CMD_REPLACE /**< replace the old layer with new one */
-#define SND_SEQ_INSTR_PUT_CMD_MODIFY SNDRV_SEQ_INSTR_PUT_CMD_MODIFY /**< modify the existing layer */
-#define SND_SEQ_INSTR_PUT_CMD_ADD SNDRV_SEQ_INSTR_PUT_CMD_ADD /**< add one to the existing layer */
-#define SND_SEQ_INSTR_PUT_CMD_REMOVE SNDRV_SEQ_INSTR_PUT_CMD_REMOVE /**< remove the layer */
+#define SND_SEQ_INSTR_PUT_CMD_CREATE 0 /**< create a new layer */
+#define SND_SEQ_INSTR_PUT_CMD_REPLACE 1 /**< replace the old layer with new one */
+#define SND_SEQ_INSTR_PUT_CMD_MODIFY 2 /**< modify the existing layer */
+#define SND_SEQ_INSTR_PUT_CMD_ADD 3 /**< add one to the existing layer */
+#define SND_SEQ_INSTR_PUT_CMD_REMOVE 4 /**< remove the layer */
/** get commands */
-#define SND_SEQ_INSTR_GET_CMD_FULL SNDRV_SEQ_INSTR_GET_CMD_FULL /**< get the full data stream */
-#define SND_SEQ_INSTR_GET_CMD_PARTIAL SNDRV_SEQ_INSTR_GET_CMD_PARTIAL /**< get the partial data stream */
+#define SND_SEQ_INSTR_GET_CMD_FULL 0 /**< get the full data stream */
+#define SND_SEQ_INSTR_GET_CMD_PARTIAL 1 /**< get the partial data stream */
+
+/* query flags */
+#define SND_SEQ_INSTR_QUERY_FOLLOW_ALIAS (1<<0)
/** free commands */
-#define SND_SEQ_INSTR_FREE_CMD_ALL SNDRV_SEQ_INSTR_FREE_CMD_ALL /**< remove all matching instruments */
-#define SND_SEQ_INSTR_FREE_CMD_PRIVATE SNDRV_SEQ_INSTR_FREE_CMD_PRIVATE /**< remove only private instruments */
-#define SND_SEQ_INSTR_FREE_CMD_CLUSTER SNDRV_SEQ_INSTR_FREE_CMD_CLUSTER /**< remove only cluster instruments */
-#define SND_SEQ_INSTR_FREE_CMD_SINGLE SNDRV_SEQ_INSTR_FREE_CMD_SINGLE /**< remove single instrument */
+#define SND_SEQ_INSTR_FREE_CMD_ALL 0 /**< remove all matching instruments */
+#define SND_SEQ_INSTR_FREE_CMD_PRIVATE 1 /**< remove only private instruments */
+#define SND_SEQ_INSTR_FREE_CMD_CLUSTER 2 /**< remove only cluster instruments */
+#define SND_SEQ_INSTR_FREE_CMD_SINGLE 3 /**< remove single instrument */
/**
#define _snd_hwdep_info sndrv_hwdep_info
-#define _SND_SEQ_IN_LOCAL 1
#define _snd_seq_queue_tempo sndrv_seq_queue_tempo
#define _snd_seq_client_info sndrv_seq_client_info
#define _snd_seq_port_info sndrv_seq_port_info
#define _snd_seq_remove_events sndrv_seq_remove_events
#define _snd_instr_header sndrv_seq_instr_header
+#if 0
typedef struct sndrv_seq_addr snd_seq_addr_t;
#define snd_seq_tick_time_t sndrv_seq_tick_time_t
typedef struct sndrv_seq_real_time snd_seq_real_time_t;
typedef struct sndrv_seq_instr snd_seq_instr_t;
typedef struct sndrv_seq_event snd_seq_event_t;
#define snd_seq_instr_cluster_t sndrv_seq_instr_cluster_t
+#endif
#define _snd_timer_id sndrv_timer_id
#define _snd_timer_select sndrv_timer_select
#define _snd_timer_params sndrv_timer_params
#define _snd_timer_status sndrv_timer_status
+#include <sound/asound.h>
+#include <sound/asequencer.h>
#include "asoundlib.h"
#include "list.h"
/** PCM class */
typedef enum _snd_pcm_class {
/** standard device */
- SND_PCM_CLASS_GENERIC = SNDRV_PCM_CLASS_GENERIC,
+ SND_PCM_CLASS_GENERIC = 0,
/** multichannel device */
- SND_PCM_CLASS_MULTI = SNDRV_PCM_CLASS_MULTI,
+ SND_PCM_CLASS_MULTI,
/** software modem device */
- SND_PCM_CLASS_MODEM = SNDRV_PCM_CLASS_MODEM,
+ SND_PCM_CLASS_MODEM,
/** digitizer device */
- SND_PCM_CLASS_DIGITIZER = SNDRV_PCM_CLASS_DIGITIZER,
- SND_PCM_CLASS_LAST = SNDRV_PCM_CLASS_LAST,
+ SND_PCM_CLASS_DIGITIZER,
+ SND_PCM_CLASS_LAST = SND_PCM_CLASS_DIGITIZER,
} snd_pcm_class_t;
/** PCM subclass */
typedef enum _snd_pcm_subclass {
/** subdevices are mixed together */
- SND_PCM_SUBCLASS_GENERIC_MIX = SNDRV_PCM_SUBCLASS_GENERIC_MIX,
+ SND_PCM_SUBCLASS_GENERIC_MIX = 0,
/** multichannel subdevices are mixed together */
- SND_PCM_SUBCLASS_MULTI_MIX = SNDRV_PCM_SUBCLASS_MULTI_MIX,
- SND_PCM_SUBCLASS_LAST = SNDRV_PCM_SUBCLASS_LAST,
+ SND_PCM_SUBCLASS_MULTI_MIX,
+ SND_PCM_SUBCLASS_LAST = SND_PCM_SUBCLASS_MULTI_MIX,
} snd_pcm_subclass_t;
/** PCM stream (direction) */
typedef enum _snd_pcm_stream {
/** Playback stream */
- SND_PCM_STREAM_PLAYBACK = SNDRV_PCM_STREAM_PLAYBACK,
+ SND_PCM_STREAM_PLAYBACK = 0,
/** Capture stream */
- SND_PCM_STREAM_CAPTURE = SNDRV_PCM_STREAM_CAPTURE,
- SND_PCM_STREAM_LAST = SNDRV_PCM_STREAM_LAST,
+ SND_PCM_STREAM_CAPTURE,
+ SND_PCM_STREAM_LAST = SND_PCM_STREAM_CAPTURE,
} snd_pcm_stream_t;
/** PCM access type */
typedef enum _snd_pcm_access {
/** mmap access with simple interleaved channels */
- SND_PCM_ACCESS_MMAP_INTERLEAVED = SNDRV_PCM_ACCESS_MMAP_INTERLEAVED,
+ SND_PCM_ACCESS_MMAP_INTERLEAVED = 0,
/** mmap access with simple non interleaved channels */
- SND_PCM_ACCESS_MMAP_NONINTERLEAVED = SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED,
+ SND_PCM_ACCESS_MMAP_NONINTERLEAVED,
/** mmap access with complex placement */
- SND_PCM_ACCESS_MMAP_COMPLEX = SNDRV_PCM_ACCESS_MMAP_COMPLEX,
+ SND_PCM_ACCESS_MMAP_COMPLEX,
/** snd_pcm_readi/snd_pcm_writei access */
- SND_PCM_ACCESS_RW_INTERLEAVED = SNDRV_PCM_ACCESS_RW_INTERLEAVED,
+ SND_PCM_ACCESS_RW_INTERLEAVED,
/** snd_pcm_readn/snd_pcm_writen access */
- SND_PCM_ACCESS_RW_NONINTERLEAVED = SNDRV_PCM_ACCESS_RW_NONINTERLEAVED,
- SND_PCM_ACCESS_LAST = SNDRV_PCM_ACCESS_LAST,
+ SND_PCM_ACCESS_RW_NONINTERLEAVED,
+ SND_PCM_ACCESS_LAST = SND_PCM_ACCESS_RW_NONINTERLEAVED,
} snd_pcm_access_t;
/** PCM sample format */
/** Unknown */
SND_PCM_FORMAT_UNKNOWN = -1,
/** Signed 8 bit */
- SND_PCM_FORMAT_S8 = SNDRV_PCM_FORMAT_S8,
+ SND_PCM_FORMAT_S8 = 0,
/** Unsigned 8 bit */
- SND_PCM_FORMAT_U8 = SNDRV_PCM_FORMAT_U8,
+ SND_PCM_FORMAT_U8,
/** Signed 16 bit Little Endian */
- SND_PCM_FORMAT_S16_LE = SNDRV_PCM_FORMAT_S16_LE,
+ SND_PCM_FORMAT_S16_LE,
/** Signed 16 bit Big Endian */
- SND_PCM_FORMAT_S16_BE = SNDRV_PCM_FORMAT_S16_BE,
+ SND_PCM_FORMAT_S16_BE,
/** Unsigned 16 bit Little Endian */
- SND_PCM_FORMAT_U16_LE = SNDRV_PCM_FORMAT_U16_LE,
+ SND_PCM_FORMAT_U16_LE,
/** Unsigned 16 bit Big Endian */
- SND_PCM_FORMAT_U16_BE = SNDRV_PCM_FORMAT_U16_BE,
+ SND_PCM_FORMAT_U16_BE,
/** Signed 24 bit Little Endian */
- SND_PCM_FORMAT_S24_LE = SNDRV_PCM_FORMAT_S24_LE,
+ SND_PCM_FORMAT_S24_LE,
/** Signed 24 bit Big Endian */
- SND_PCM_FORMAT_S24_BE = SNDRV_PCM_FORMAT_S24_BE,
+ SND_PCM_FORMAT_S24_BE,
/** Unsigned 24 bit Little Endian */
- SND_PCM_FORMAT_U24_LE = SNDRV_PCM_FORMAT_U24_LE,
+ SND_PCM_FORMAT_U24_LE,
/** Unsigned 24 bit Big Endian */
- SND_PCM_FORMAT_U24_BE = SNDRV_PCM_FORMAT_U24_BE,
+ SND_PCM_FORMAT_U24_BE,
/** Signed 32 bit Little Endian */
- SND_PCM_FORMAT_S32_LE = SNDRV_PCM_FORMAT_S32_LE,
+ SND_PCM_FORMAT_S32_LE,
/** Signed 32 bit Big Endian */
- SND_PCM_FORMAT_S32_BE = SNDRV_PCM_FORMAT_S32_BE,
+ SND_PCM_FORMAT_S32_BE,
/** Unsigned 32 bit Little Endian */
- SND_PCM_FORMAT_U32_LE = SNDRV_PCM_FORMAT_U32_LE,
+ SND_PCM_FORMAT_U32_LE,
/** Unsigned 32 bit Big Endian */
- SND_PCM_FORMAT_U32_BE = SNDRV_PCM_FORMAT_U32_BE,
+ SND_PCM_FORMAT_U32_BE,
/** Float 32 bit Little Endian */
- SND_PCM_FORMAT_FLOAT_LE = SNDRV_PCM_FORMAT_FLOAT_LE,
+ SND_PCM_FORMAT_FLOAT_LE,
/** Float 32 bit Big Endian */
- SND_PCM_FORMAT_FLOAT_BE = SNDRV_PCM_FORMAT_FLOAT_BE,
+ SND_PCM_FORMAT_FLOAT_BE,
/** Float 64 bit Little Endian */
- SND_PCM_FORMAT_FLOAT64_LE = SNDRV_PCM_FORMAT_FLOAT64_LE,
+ SND_PCM_FORMAT_FLOAT64_LE,
/** Float 64 bit Big Endian */
- SND_PCM_FORMAT_FLOAT64_BE = SNDRV_PCM_FORMAT_FLOAT64_BE,
+ SND_PCM_FORMAT_FLOAT64_BE,
/** IEC-958 Little Endian */
- SND_PCM_FORMAT_IEC958_SUBFRAME_LE = SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE,
+ SND_PCM_FORMAT_IEC958_SUBFRAME_LE,
/** IEC-958 Big Endian */
- SND_PCM_FORMAT_IEC958_SUBFRAME_BE = SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE,
+ SND_PCM_FORMAT_IEC958_SUBFRAME_BE,
/** Mu-Law */
- SND_PCM_FORMAT_MU_LAW = SNDRV_PCM_FORMAT_MU_LAW,
+ SND_PCM_FORMAT_MU_LAW,
/** A-Law */
- SND_PCM_FORMAT_A_LAW = SNDRV_PCM_FORMAT_A_LAW,
+ SND_PCM_FORMAT_A_LAW,
/** Ima-ADPCM */
- SND_PCM_FORMAT_IMA_ADPCM = SNDRV_PCM_FORMAT_IMA_ADPCM,
+ SND_PCM_FORMAT_IMA_ADPCM,
/** MPEG */
- SND_PCM_FORMAT_MPEG = SNDRV_PCM_FORMAT_MPEG,
+ SND_PCM_FORMAT_MPEG,
/** GSM */
- SND_PCM_FORMAT_GSM = SNDRV_PCM_FORMAT_GSM,
+ SND_PCM_FORMAT_GSM,
/** Special */
- SND_PCM_FORMAT_SPECIAL = SNDRV_PCM_FORMAT_SPECIAL,
- SND_PCM_FORMAT_LAST = SNDRV_PCM_FORMAT_LAST,
+ SND_PCM_FORMAT_SPECIAL = 31,
+ SND_PCM_FORMAT_LAST = SND_PCM_FORMAT_SPECIAL,
+
+#if __BYTE_ORDER == __LITTLE_ENDIAN
/** Signed 16 bit CPU endian */
- SND_PCM_FORMAT_S16 = SNDRV_PCM_FORMAT_S16,
+ SND_PCM_FORMAT_S16 = SND_PCM_FORMAT_S16_LE,
/** Unsigned 16 bit CPU endian */
- SND_PCM_FORMAT_U16 = SNDRV_PCM_FORMAT_U16,
+ SND_PCM_FORMAT_U16 = SND_PCM_FORMAT_U16_LE,
/** Signed 24 bit CPU endian */
- SND_PCM_FORMAT_S24 = SNDRV_PCM_FORMAT_S24,
+ SND_PCM_FORMAT_S24 = SND_PCM_FORMAT_S24_LE,
/** Unsigned 24 bit CPU endian */
- SND_PCM_FORMAT_U24 = SNDRV_PCM_FORMAT_U24,
+ SND_PCM_FORMAT_U24 = SND_PCM_FORMAT_U24_LE,
/** Signed 32 bit CPU endian */
- SND_PCM_FORMAT_S32 = SNDRV_PCM_FORMAT_S32,
+ SND_PCM_FORMAT_S32 = SND_PCM_FORMAT_S32_LE,
/** Unsigned 32 bit CPU endian */
- SND_PCM_FORMAT_U32 = SNDRV_PCM_FORMAT_U32,
+ SND_PCM_FORMAT_U32 = SND_PCM_FORMAT_U32_LE,
/** Float 32 bit CPU endian */
- SND_PCM_FORMAT_FLOAT = SNDRV_PCM_FORMAT_FLOAT,
+ SND_PCM_FORMAT_FLOAT = SND_PCM_FORMAT_FLOAT_LE,
/** Float 64 bit CPU endian */
- SND_PCM_FORMAT_FLOAT64 = SNDRV_PCM_FORMAT_FLOAT64,
+ SND_PCM_FORMAT_FLOAT64 = SND_PCM_FORMAT_FLOAT64_LE,
/** IEC-958 CPU Endian */
- SND_PCM_FORMAT_IEC958_SUBFRAME = SNDRV_PCM_FORMAT_IEC958_SUBFRAME,
+ SND_PCM_FORMAT_IEC958_SUBFRAME = SND_PCM_FORMAT_IEC958_SUBFRAME_LE,
+#elif __BYTE_ORDER == __BIG_ENDIAN
+ /** Signed 16 bit CPU endian */
+ SND_PCM_FORMAT_S16 = SND_PCM_FORMAT_S16_BE,
+ /** Unsigned 16 bit CPU endian */
+ SND_PCM_FORMAT_U16 = SND_PCM_FORMAT_U16_BE,
+ /** Signed 24 bit CPU endian */
+ SND_PCM_FORMAT_S24 = SND_PCM_FORMAT_S24_BE,
+ /** Unsigned 24 bit CPU endian */
+ SND_PCM_FORMAT_U24 = SND_PCM_FORMAT_U24_BE,
+ /** Signed 32 bit CPU endian */
+ SND_PCM_FORMAT_S32 = SND_PCM_FORMAT_S32_BE,
+ /** Unsigned 32 bit CPU endian */
+ SND_PCM_FORMAT_U32 = SND_PCM_FORMAT_U32_BE,
+ /** Float 32 bit CPU endian */
+ SND_PCM_FORMAT_FLOAT = SND_PCM_FORMAT_FLOAT_BE,
+ /** Float 64 bit CPU endian */
+ SND_PCM_FORMAT_FLOAT64 = SND_PCM_FORMAT_FLOAT64_BE,
+ /** IEC-958 CPU Endian */
+ SND_PCM_FORMAT_IEC958_SUBFRAME = SND_PCM_FORMAT_IEC958_SUBFRAME_BE,
+#else
+#error "Unknown endian"
+#endif
} snd_pcm_format_t;
/** PCM sample subformat */
typedef enum _snd_pcm_subformat {
/** Standard */
- SND_PCM_SUBFORMAT_STD = SNDRV_PCM_SUBFORMAT_STD,
- SND_PCM_SUBFORMAT_LAST = SNDRV_PCM_SUBFORMAT_LAST,
+ SND_PCM_SUBFORMAT_STD = 0,
+ SND_PCM_SUBFORMAT_LAST = SND_PCM_SUBFORMAT_STD,
} snd_pcm_subformat_t;
/** PCM state */
typedef enum _snd_pcm_state {
/** Open */
- SND_PCM_STATE_OPEN = SNDRV_PCM_STATE_OPEN,
+ SND_PCM_STATE_OPEN = 0,
/** Setup installed */
- SND_PCM_STATE_SETUP = SNDRV_PCM_STATE_SETUP,
+ SND_PCM_STATE_SETUP,
/** Ready to start */
- SND_PCM_STATE_PREPARED = SNDRV_PCM_STATE_PREPARED,
+ SND_PCM_STATE_PREPARED,
/** Running */
- SND_PCM_STATE_RUNNING = SNDRV_PCM_STATE_RUNNING,
+ SND_PCM_STATE_RUNNING,
/** Stopped: underrun (playback) or overrun (capture) detected */
- SND_PCM_STATE_XRUN = SNDRV_PCM_STATE_XRUN,
+ SND_PCM_STATE_XRUN,
/** Draining: running (playback) or stopped (capture) */
- SND_PCM_STATE_DRAINING = SNDRV_PCM_STATE_DRAINING,
+ SND_PCM_STATE_DRAINING,
/** Paused */
- SND_PCM_STATE_PAUSED = SNDRV_PCM_STATE_PAUSED,
- SND_PCM_STATE_LAST = SNDRV_PCM_STATE_LAST,
+ SND_PCM_STATE_PAUSED,
+ SND_PCM_STATE_LAST = SND_PCM_STATE_PAUSED,
} snd_pcm_state_t;
/** PCM start mode */
typedef enum _snd_pcm_start {
/** Automatic start on data read/write */
- SND_PCM_START_DATA,
+ SND_PCM_START_DATA = 0,
/** Explicit start */
SND_PCM_START_EXPLICIT,
- SND_PCM_START_LAST,
+ SND_PCM_START_LAST = SND_PCM_START_EXPLICIT,
} snd_pcm_start_t;
/** PCM xrun mode */
typedef enum _snd_pcm_xrun {
/** Xrun detection disabled */
- SND_PCM_XRUN_NONE,
+ SND_PCM_XRUN_NONE = 0,
/** Stop on xrun detection */
SND_PCM_XRUN_STOP,
- SND_PCM_XRUN_LAST,
+ SND_PCM_XRUN_LAST = SND_PCM_XRUN_STOP,
} snd_pcm_xrun_t;
/** PCM timestamp mode */
typedef enum _snd_pcm_tstamp {
/** No timestamp */
- SND_PCM_TSTAMP_NONE = SNDRV_PCM_TSTAMP_NONE,
+ SND_PCM_TSTAMP_NONE = 0,
/** Update mmap'ed timestamp */
- SND_PCM_TSTAMP_MMAP = SNDRV_PCM_TSTAMP_MMAP,
- SND_PCM_TSTAMP_LAST = SNDRV_PCM_TSTAMP_LAST,
+ SND_PCM_TSTAMP_MMAP,
+ SND_PCM_TSTAMP_LAST = SND_PCM_TSTAMP_MMAP,
} snd_pcm_tstamp_t;
/** Unsigned frames quantity */
/** PCM type */
enum _snd_pcm_type {
/** Kernel level PCM */
- SND_PCM_TYPE_HW,
+ SND_PCM_TYPE_HW = 0,
/** Hooked PCM */
SND_PCM_TYPE_HOOKS,
/** One ore more linked PCM with exclusive access to selected
/** type of pcm hook */
typedef enum _snd_pcm_hook_type {
- SND_PCM_HOOK_TYPE_HW_PARAMS,
+ SND_PCM_HOOK_TYPE_HW_PARAMS = 0,
SND_PCM_HOOK_TYPE_HW_FREE,
SND_PCM_HOOK_TYPE_CLOSE,
SND_PCM_HOOK_TYPE_LAST = SND_PCM_HOOK_TYPE_CLOSE,
/** RawMidi stream (direction) */
typedef enum _snd_rawmidi_stream {
/** Output stream */
- SND_RAWMIDI_STREAM_OUTPUT = SNDRV_RAWMIDI_STREAM_OUTPUT,
+ SND_RAWMIDI_STREAM_OUTPUT = 0,
/** Input stream */
- SND_RAWMIDI_STREAM_INPUT = SNDRV_RAWMIDI_STREAM_INPUT,
- SND_RAWMIDI_STREAM_LAST = SNDRV_RAWMIDI_STREAM_LAST,
+ SND_RAWMIDI_STREAM_INPUT,
+ SND_RAWMIDI_STREAM_LAST = SND_RAWMIDI_STREAM_INPUT,
} snd_rawmidi_stream_t;
/** Append \hideinitializer */
};
-#ifdef _SND_SEQ_IN_LOCAL
-#include <sound/asequencer.h>
-#else
-
/** Sequencer event address */
typedef struct snd_seq_addr {
unsigned char client; /**< Client id */
} data; /**< event data... */
} snd_seq_event_t;
-#endif /* _SND_SEQ_IN_LOCAL */
-
/** \} */
/** timer master class */
typedef enum _snd_timer_class {
- SND_TIMER_CLASS_NONE = SNDRV_TIMER_CLASS_NONE, /**< invalid */
- SND_TIMER_CLASS_SLAVE = SNDRV_TIMER_CLASS_SLAVE, /**< slave timer */
- SND_TIMER_CLASS_GLOBAL = SNDRV_TIMER_CLASS_GLOBAL, /**< global timer */
- SND_TIMER_CLASS_CARD = SNDRV_TIMER_CLASS_CARD, /**< card timer */
- SND_TIMER_CLASS_PCM = SNDRV_TIMER_CLASS_PCM, /**< PCM timer */
- SND_TIMER_CLASS_LAST = SNDRV_TIMER_CLASS_LAST, /**< last timer */
+ SND_TIMER_CLASS_NONE = -1, /**< invalid */
+ SND_TIMER_CLASS_SLAVE = 0, /**< slave timer */
+ SND_TIMER_CLASS_GLOBAL, /**< global timer */
+ SND_TIMER_CLASS_CARD, /**< card timer */
+ SND_TIMER_CLASS_PCM, /**< PCM timer */
+ SND_TIMER_CLASS_LAST = SND_TIMER_CLASS_PCM, /**< last timer */
} snd_timer_class_t;
/** timer slave class */
typedef enum _snd_timer_slave_class {
- SND_TIMER_SCLASS_NONE = SNDRV_TIMER_SCLASS_NONE, /**< none */
- SND_TIMER_SCLASS_APPLICATION = SNDRV_TIMER_SCLASS_APPLICATION, /**< for internal use */
- SND_TIMER_SCLASS_SEQUENCER = SNDRV_TIMER_SCLASS_SEQUENCER, /**< sequencer timer */
- SND_TIMER_SCLASS_OSS_SEQUENCER = SNDRV_TIMER_SCLASS_OSS_SEQUENCER, /**< OSS sequencer timer */
- SND_TIMER_SCLASS_LAST = SNDRV_TIMER_SCLASS_LAST, /**< last slave timer */
+ SND_TIMER_SCLASS_NONE = 0, /**< none */
+ SND_TIMER_SCLASS_APPLICATION, /**< for internal use */
+ SND_TIMER_SCLASS_SEQUENCER, /**< sequencer timer */
+ SND_TIMER_SCLASS_OSS_SEQUENCER, /**< OSS sequencer timer */
+ SND_TIMER_SCLASS_LAST = SND_TIMER_SCLASS_OSS_SEQUENCER, /**< last slave timer */
} snd_timer_slave_class_t;
/** global timer - system */
-#define SND_TIMER_GLOBAL_SYSTEM SNDRV_TIMER_GLOBAL_SYSTEM
+#define SND_TIMER_GLOBAL_SYSTEM 0
/** global timer - RTC */
-#define SND_TIMER_GLOBAL_RTC SNDRV_TIMER_GLOBAL_RTC
+#define SND_TIMER_GLOBAL_RTC 1
/** timer open mode flag - nonblock */
#define SND_TIMER_OPEN_NONBLOCK 1
/** timer handle type */
typedef enum _snd_timer_type {
/** Kernel level HwDep */
- SND_TIMER_TYPE_HW,
+ SND_TIMER_TYPE_HW = 0,
/** Shared memory client timer (not yet implemented) */
SND_TIMER_TYPE_SHM,
/** INET client timer (not yet implemented) */
PLUG_ROUTE_POLICY_NONE,
PLUG_ROUTE_POLICY_DEFAULT,
PLUG_ROUTE_POLICY_COPY,
- PLUG_ROUTE_POLICY_SUM,
+ PLUG_ROUTE_POLICY_AVERAGE,
PLUG_ROUTE_POLICY_DUP,
};
if (rpolicy == PLUG_ROUTE_POLICY_DEFAULT) {
rpolicy = PLUG_ROUTE_POLICY_COPY;
if (pcm->stream == SND_PCM_STREAM_CAPTURE && clt->channels == 1)
- rpolicy = PLUG_ROUTE_POLICY_SUM;
+ rpolicy = PLUG_ROUTE_POLICY_AVERAGE;
+ if (pcm->stream == SND_PCM_STREAM_PLAYBACK && slv->channels == 1)
+ rpolicy = PLUG_ROUTE_POLICY_AVERAGE;
}
switch (rpolicy) {
- case PLUG_ROUTE_POLICY_SUM:
+ case PLUG_ROUTE_POLICY_AVERAGE:
case PLUG_ROUTE_POLICY_DUP:
if (clt->channels > slv->channels) {
n = clt->channels;
}
while (n-- > 0) {
snd_pcm_route_ttable_entry_t v = FULL;
- if (rpolicy == PLUG_ROUTE_POLICY_SUM) {
+ if (rpolicy == PLUG_ROUTE_POLICY_AVERAGE) {
if (pcm->stream == SND_PCM_STREAM_PLAYBACK &&
clt->channels > slv->channels) {
int srcs = clt->channels / slv->channels;
SNDERR("Table is defined, route policy is ignored");
if (!strcmp(str, "default"))
route_policy = PLUG_ROUTE_POLICY_DEFAULT;
- else if (!strcmp(str, "sum"))
- route_policy = PLUG_ROUTE_POLICY_SUM;
+ else if (!strcmp(str, "average"))
+ route_policy = PLUG_ROUTE_POLICY_AVERAGE;
else if (!strcmp(str, "copy"))
route_policy = PLUG_ROUTE_POLICY_COPY;
else if (!strcmp(str, "duplicate"))
const snd_seq_addr_t *snd_seq_port_info_get_addr(const snd_seq_port_info_t *info)
{
assert(info);
- return &info->addr;
+ return (snd_seq_addr_t *)&info->addr;
}
/**
void snd_seq_port_info_set_addr(snd_seq_port_info_t *info, const snd_seq_addr_t *addr)
{
assert(info);
- info->addr = *addr;
+ info->addr = *(struct sndrv_seq_addr *)addr;
}
/**
const snd_seq_addr_t *snd_seq_port_subscribe_get_sender(const snd_seq_port_subscribe_t *info)
{
assert(info);
- return &info->sender;
+ return (snd_seq_addr_t *)&info->sender;
}
/**
const snd_seq_addr_t *snd_seq_port_subscribe_get_dest(const snd_seq_port_subscribe_t *info)
{
assert(info);
- return &info->dest;
+ return (snd_seq_addr_t *)&info->dest;
}
/**
const snd_seq_addr_t *snd_seq_query_subscribe_get_root(const snd_seq_query_subscribe_t *info)
{
assert(info);
- return &info->root;
+ return (snd_seq_addr_t *)&info->root;
}
/**
const snd_seq_addr_t *snd_seq_query_subscribe_get_addr(const snd_seq_query_subscribe_t *info)
{
assert(info);
- return &info->addr;
+ return (snd_seq_addr_t *)&info->addr;
}
/**
void snd_seq_query_subscribe_set_root(snd_seq_query_subscribe_t *info, const snd_seq_addr_t *addr)
{
assert(info);
- info->root = *addr;
+ info->root = *(struct sndrv_seq_addr *)addr;
}
/**
const snd_seq_real_time_t *snd_seq_queue_status_get_real_time(const snd_seq_queue_status_t *info)
{
assert(info);
- return &info->time;
+ return (snd_seq_real_time_t *)&info->time;
}
/**
const snd_seq_timestamp_t *snd_seq_remove_events_get_time(const snd_seq_remove_events_t *info)
{
assert(info);
- return &info->time;
+ return (snd_seq_timestamp_t *)&info->time;
}
/**
const snd_seq_addr_t *snd_seq_remove_events_get_dest(const snd_seq_remove_events_t *info)
{
assert(info);
- return &info->dest;
+ return (snd_seq_addr_t *)&info->dest;
}
/**
void snd_seq_remove_events_set_time(snd_seq_remove_events_t *info, const snd_seq_timestamp_t *time)
{
assert(info);
- info->time = *time;
+ info->time = *(union sndrv_seq_timestamp *)time;
}
/**
void snd_seq_remove_events_set_dest(snd_seq_remove_events_t *info, const snd_seq_addr_t *addr)
{
assert(info);
- info->dest = *addr;
+ info->dest = *(struct sndrv_seq_addr *)addr;
}
/**
/* compare timestamp between events */
/* return 1 if a >= b; otherwise return 0 */
-static inline int snd_seq_compare_tick_time(sndrv_seq_tick_time_t *a, sndrv_seq_tick_time_t *b)
+static inline int snd_seq_compare_tick_time(snd_seq_tick_time_t *a, snd_seq_tick_time_t *b)
{
/* compare ticks */
return (*a >= *b);
}
-static inline int snd_seq_compare_real_time(struct sndrv_seq_real_time *a, struct sndrv_seq_real_time *b)
+static inline int snd_seq_compare_real_time(snd_seq_real_time_t *a, snd_seq_real_time_t *b)
{
/* compare real time */
if (a->tv_sec > b->tv_sec)
}
if (info->remove_mode & SNDRV_SEQ_REMOVE_TIME_AFTER) {
if (info->remove_mode & SNDRV_SEQ_REMOVE_TIME_TICK)
- res = snd_seq_compare_tick_time(&ev->time.tick, &info->time.tick);
+ res = snd_seq_compare_tick_time(&ev->time.tick, (snd_seq_tick_time_t *)&info->time.tick);
else
- res = snd_seq_compare_real_time(&ev->time.time, &info->time.time);
+ res = snd_seq_compare_real_time(&ev->time.time, (snd_seq_real_time_t *)&info->time.time);
if (!res)
return 0;
}
if (info->remove_mode & SNDRV_SEQ_REMOVE_TIME_BEFORE) {
if (info->remove_mode & SNDRV_SEQ_REMOVE_TIME_TICK)
- res = snd_seq_compare_tick_time(&ev->time.tick, &info->time.tick);
+ res = snd_seq_compare_tick_time(&ev->time.tick, (snd_seq_tick_time_t *)&info->time.tick);
else
- res = snd_seq_compare_real_time(&ev->time.time, &info->time.time);
+ res = snd_seq_compare_real_time(&ev->time.time, (snd_seq_real_time_t *)&info->time.time);
if (res)
return 0;
}
const snd_seq_instr_t *snd_instr_header_get_id(const snd_instr_header_t *info)
{
assert(info);
- return &info->id.instr;
+ return (snd_seq_instr_t *)&info->id.instr;
}
/**
const snd_seq_instr_t *snd_instr_header_get_alias(const snd_instr_header_t *info)
{
assert(info);
- return &info->data.data.alias;
+ return (snd_seq_instr_t *)&info->data.data.alias;
}
/**
void snd_instr_header_set_id(snd_instr_header_t *info, const snd_seq_instr_t *id)
{
assert(info && id);
- info->id.instr = *id;
+ info->id.instr = *(struct sndrv_seq_instr *)id;
}
/**
void snd_instr_header_set_alias(snd_instr_header_t *info, const snd_seq_instr_t *instr)
{
assert(info && instr);
- info->data.data.alias = *instr;
+ info->data.data.alias = *(struct sndrv_seq_instr *)instr;
}
/**
* \date 2001
*/
-#include "../../include/asoundlib.h"
+#include "local.h"
#ifndef DOC_HIDDEN
#define FIXED_EV(x) (_SND_SEQ_TYPE(SND_SEQ_EVFLG_FIXED) | _SND_SEQ_TYPE(x))
-check_PROGRAMS=control mixer switches pause pcm pcmtest latency seq \
+check_PROGRAMS=control mixer switches pause pcm latency seq \
playmidi1 timer loopback rawmidi midiloop cardid
control_LDADD=../src/libasound.la
switches_LDADD=../src/libasound.la
pause_LDADD=../src/libasound.la
pcm_LDADD=../src/libasound.la
-pcmtest_LDADD=../src/libasound.la
latency_LDADD=../src/libasound.la
seq_LDADD=../src/libasound.la
playmidi1_LDADD=../src/libasound.la
+++ /dev/null
-#include <stdio.h>
-#include <string.h>
-#include "../include/asoundlib.h"
-
-void info_channel(snd_pcm_t *handle, int channel, char *id)
-{
- snd_pcm_stream_info_t stream_info;
- int err;
-
- bzero(&stream_info, sizeof(stream_info));
- stream_info.channel = channel;
- if ((err = snd_pcm_stream_info(handle, &stream_info))<0) {
- fprintf(stderr, "channel info error: %s\n", snd_strerror(err));
- return;
- }
- printf("%s INFO:\n", id);
- printf(" subdevice : %i\n", stream_info.subdevice);
- printf(" subname : '%s'\n", stream_info.subname);
- printf(" channel : %i\n", stream_info.channel);
- printf(" mode : ");
- switch (stream_info.mode) {
- case SND_PCM_MODE_FRAME:
- printf("frame\n");
- break;
- case SND_PCM_MODE_FRAGMENT:
- printf("fragment\n");
- break;
- default:
- printf("unknown\n");
- }
- printf(" sync : 0x%x, 0x%x, 0x%x, 0x%x\n",
- stream_info.sync.id32[0],
- stream_info.sync.id32[1],
- stream_info.sync.id32[2],
- stream_info.sync.id32[3]);
- printf(" flags :");
- if (stream_info.flags & SND_PCM_STREAM_INFO_MMAP)
- printf(" mmap");
- if (stream_info.flags & SND_PCM_STREAM_INFO_FRAME)
- printf(" frame");
- if (stream_info.flags & SND_PCM_STREAM_INFO_FRAGMENT)
- printf(" fragment");
- if (stream_info.flags & SND_PCM_STREAM_INFO_BATCH)
- printf(" batch");
- if (stream_info.flags & SND_PCM_STREAM_INFO_INTERLEAVE)
- printf(" interleave");
- if (stream_info.flags & SND_PCM_STREAM_INFO_NONINTERLEAVE)
- printf(" noninterleave");
- if (stream_info.flags & SND_PCM_STREAM_INFO_BLOCK_TRANSFER)
- printf(" block_transfer");
- if (stream_info.flags & SND_PCM_STREAM_INFO_OVERRANGE)
- printf(" overrange");
- printf("\n");
- printf(" formats :");
- if (stream_info.formats & SND_PCM_FMTBIT_MU_LAW)
- printf(" mu-Law");
- if (stream_info.formats & SND_PCM_FMTBIT_A_LAW)
- printf(" a-Law");
- if (stream_info.formats & SND_PCM_FMTBIT_IMA_ADPCM)
- printf(" IMA-ADPCM");
- if (stream_info.formats & SND_PCM_FMTBIT_U8)
- printf(" U8");
- if (stream_info.formats & SND_PCM_FMTBIT_S16_LE)
- printf(" S16-LE");
- if (stream_info.formats & SND_PCM_FMTBIT_S16_BE)
- printf(" S16-BE");
- if (stream_info.formats & SND_PCM_FMTBIT_S8)
- printf(" S8");
- if (stream_info.formats & SND_PCM_FMTBIT_U16_LE)
- printf(" U16-LE");
- if (stream_info.formats & SND_PCM_FMTBIT_U16_BE)
- printf(" U16-BE");
- if (stream_info.formats & SND_PCM_FMTBIT_MPEG)
- printf(" MPEG");
- if (stream_info.formats & SND_PCM_FMTBIT_GSM)
- printf(" GSM");
- if (stream_info.formats & SND_PCM_FMTBIT_S24_LE)
- printf(" S24-LE");
- if (stream_info.formats & SND_PCM_FMTBIT_S24_BE)
- printf(" S24-BE");
- if (stream_info.formats & SND_PCM_FMTBIT_U24_LE)
- printf(" U24-LE");
- if (stream_info.formats & SND_PCM_FMTBIT_U24_BE)
- printf(" U24-BE");
- if (stream_info.formats & SND_PCM_FMTBIT_S32_LE)
- printf(" S32-LE");
- if (stream_info.formats & SND_PCM_FMTBIT_S32_BE)
- printf(" S32-BE");
- if (stream_info.formats & SND_PCM_FMTBIT_U32_LE)
- printf(" U32-LE");
- if (stream_info.formats & SND_PCM_FMTBIT_U32_BE)
- printf(" U32-BE");
- if (stream_info.formats & SND_PCM_FMTBIT_FLOAT)
- printf(" Float");
- if (stream_info.formats & SND_PCM_FMTBIT_FLOAT64)
- printf(" Float64");
- if (stream_info.formats & SND_PCM_FMTBIT_IEC958_SUBFRAME_LE)
- printf(" IEC958-LE");
- if (stream_info.formats & SND_PCM_FMTBIT_IEC958_SUBFRAME_BE)
- printf(" IEC958-BE");
- if (stream_info.formats & SND_PCM_FMTBIT_SPECIAL)
- printf(" Special");
- printf("\n");
- printf(" rates :");
- if (stream_info.rates & SND_PCM_RATE_CONTINUOUS)
- printf(" Continuous");
- if (stream_info.rates & SND_PCM_RATE_KNOT)
- printf(" Knot");
- if (stream_info.rates & SND_PCM_RATE_8000)
- printf(" 8000");
- if (stream_info.rates & SND_PCM_RATE_11025)
- printf(" 11025");
- if (stream_info.rates & SND_PCM_RATE_16000)
- printf(" 16000");
- if (stream_info.rates & SND_PCM_RATE_22050)
- printf(" 22050");
- if (stream_info.rates & SND_PCM_RATE_32000)
- printf(" 32000");
- if (stream_info.rates & SND_PCM_RATE_44100)
- printf(" 44100");
- if (stream_info.rates & SND_PCM_RATE_48000)
- printf(" 48000");
- if (stream_info.rates & SND_PCM_RATE_88200)
- printf(" 88200");
- if (stream_info.rates & SND_PCM_RATE_96000)
- printf(" 96000");
- if (stream_info.rates & SND_PCM_RATE_176400)
- printf(" 176400");
- if (stream_info.rates & SND_PCM_RATE_192000)
- printf(" 192000");
- printf("\n");
- printf(" min_rate : %i\n", stream_info.min_rate);
- printf(" max_rate : %i\n", stream_info.max_rate);
- printf(" min_channels : %i\n", stream_info.min_channels);
- printf(" max_channels : %i\n", stream_info.max_channels);
- printf(" buffer_size : %i\n", stream_info.buffer_size);
- printf(" min_frag_size : %i\n", stream_info.min_fragment_size);
- printf(" max_frag_size : %i\n", stream_info.max_fragment_size);
- printf(" fragment_align : %i\n", stream_info.fragment_align);
- printf(" fifo_size : %i\n", stream_info.fifo_size);
- printf(" mmap_size : %li\n", stream_info.mmap_size);
- printf(" mixer_device : %i\n", stream_info.mixer_device);
- printf(" mixer_eid : '%s',%i,%i\n", stream_info.mixer_eid.name, stream_info.mixer_eid.index, stream_info.mixer_eid.type);
-}
-
-void info(void)
-{
- snd_pcm_t *handle;
- snd_pcm_info_t info;
- int err;
-
- if ((err = snd_pcm_open(&handle, 0, 0, SND_PCM_OPEN_DUPLEX))<0) {
- fprintf(stderr, "open error: %s\n", snd_strerror(err));
- return;
- }
- if ((err = snd_pcm_info(handle, &info))<0) {
- fprintf(stderr, "pcm info error: %s\n", snd_strerror(err));
- return;
- }
- printf("INFO:\n");
- printf(" type : 0x%x\n", info.type);
- printf(" flags : 0x%x\n", info.flags);
- printf(" id : '%s'\n", info.id);
- printf(" name : '%s'\n", info.name);
- printf(" playback : %i\n", info.playback);
- printf(" capture : %i\n", info.capture);
- if (info.flags & SND_PCM_INFO_PLAYBACK)
- info_channel(handle, SND_PCM_STREAM_PLAYBACK, "Playback");
- if (info.flags & SND_PCM_INFO_CAPTURE)
- info_channel(handle, SND_PCM_STREAM_CAPTURE, "Capture");
- snd_pcm_close(handle);
-}
-
-int main(void )
-{
- info();
- return 0;
-}
OSDN Git Service
