mirrors/alsa-lib
1
0
Fork 0
mirror of https://github.com/alsa-project/alsa-lib.git synced 2025-12-15 08:56:36 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Added documentation for instrument and midi event functions.

Browse source 
Removed snd_enum_() macros.
Documentation changes in asoundlib.h.
This commit is contained in:
Jaroslav Kysela 2001-07-11 14:09:01 +00:00
parent 8eceb0cdc2
commit c20c954f3d
30 changed files with 440 additions and 227 deletions
Download patch file Download diff file Expand all files Collapse all files

4
aserver/aserver.c
View file

@ -277,7 +277,7 @@ static int pcm_shm_open(client_t *client, int *cookie)
snd_pcm_t *pcm; snd_pcm_t *pcm;
int err; int err;
int result; int result;
err = snd_pcm_open(&pcm, client->name, snd_int_to_enum(client->stream), SND_PCM_NONBLOCK); err = snd_pcm_open(&pcm, client->name, client->stream, SND_PCM_NONBLOCK);
if (err < 0) if (err < 0)
return err; return err;
client->device.pcm.handle = pcm; client->device.pcm.handle = pcm;
@ -417,7 +417,7 @@ static int pcm_shm_cmd(client_t *client)
ctrl->result = snd_pcm_status(pcm, (snd_pcm_status_t *) &ctrl->u.status); ctrl->result = snd_pcm_status(pcm, (snd_pcm_status_t *) &ctrl->u.status);
break; break;
case SND_PCM_IOCTL_STATE: case SND_PCM_IOCTL_STATE:
ctrl->result = snd_enum_to_int(snd_pcm_state(pcm)); ctrl->result = snd_pcm_state(pcm);
break; break;
case SNDRV_PCM_IOCTL_DELAY: case SNDRV_PCM_IOCTL_DELAY:
ctrl->result = snd_pcm_delay(pcm, (snd_pcm_sframes_t *) &ctrl->u.delay.frames); ctrl->result = snd_pcm_delay(pcm, (snd_pcm_sframes_t *) &ctrl->u.delay.frames);

8
include/Makefile.am
View file

@ -23,12 +23,14 @@ stamp-vh: $(top_builddir)/configure.in
@echo " * version.h" >> ver.tmp @echo " * version.h" >> ver.tmp
@echo " */" >> ver.tmp @echo " */" >> ver.tmp
@echo "" >> ver.tmp @echo "" >> ver.tmp
@echo "#define SND_LIB_MAJOR $(SND_LIB_MAJOR)" >> ver.tmp @echo "#define SND_LIB_MAJOR $(SND_LIB_MAJOR) /**< major number of library version */" >> ver.tmp
@echo "#define SND_LIB_MINOR $(SND_LIB_MINOR)" >> ver.tmp @echo "#define SND_LIB_MINOR $(SND_LIB_MINOR) /**< minor number of library version */" >> ver.tmp
@echo "#define SND_LIB_SUBMINOR $(SND_LIB_SUBMINOR)" >> ver.tmp @echo "#define SND_LIB_SUBMINOR $(SND_LIB_SUBMINOR) /**< subminor number of library version */" >> ver.tmp
@echo "/** library version */" >> ver.tmp
@echo "#define SND_LIB_VERSION ((SND_LIB_MAJOR<<16)|\\" >> ver.tmp @echo "#define SND_LIB_VERSION ((SND_LIB_MAJOR<<16)|\\" >> ver.tmp
@echo " (SND_LIB_MINOR<<8)|\\" >> ver.tmp @echo " (SND_LIB_MINOR<<8)|\\" >> ver.tmp
@echo " SND_LIB_SUBMINOR)" >> ver.tmp @echo " SND_LIB_SUBMINOR)" >> ver.tmp
@echo "/** library version (string) */" >> ver.tmp
@echo "#define SND_LIB_VERSION_STR \"$(SND_LIB_VERSION)\"" >> ver.tmp @echo "#define SND_LIB_VERSION_STR \"$(SND_LIB_VERSION)\"" >> ver.tmp
@echo >> ver.tmp @echo >> ver.tmp
@cmp -s version.h ver.tmp \ @cmp -s version.h ver.tmp \

1
include/control.h
View file

@ -84,6 +84,7 @@ typedef enum _snd_ctl_event_type {
/** Element value has been changed \hideinitializer */ /** Element value has been changed \hideinitializer */
#define SND_CTL_EVENT_MASK_VALUE SNDRV_CTL_EVENT_MASK_VALUE #define SND_CTL_EVENT_MASK_VALUE SNDRV_CTL_EVENT_MASK_VALUE
/** Element name for IEC958 (S/PDIF) */
#define SND_CTL_NAME_IEC958 SNDRV_CTL_NAME_IEC958 #define SND_CTL_NAME_IEC958 SNDRV_CTL_NAME_IEC958
/** CTL type */ /** CTL type */

8
include/conv.h
View file

@ -11,13 +11,21 @@
* \{ * \{
*/ */
/** convert 16-bit value from host to Little Endian byte order */
#define snd_host_to_LE_16(val) __cpu_to_le16(val) #define snd_host_to_LE_16(val) __cpu_to_le16(val)
/** convert 16-bit value from Little Endian to host byte order */
#define snd_LE_to_host_16(val) __le16_to_cpu(val) #define snd_LE_to_host_16(val) __le16_to_cpu(val)
/** convert 32-bit value from host to Little Endian byte order */
#define snd_host_to_LE_32(val) __cpu_to_le32(val) #define snd_host_to_LE_32(val) __cpu_to_le32(val)
/** convert 32-bit value from Little Endian to host byte order */
#define snd_LE_to_host_32(val) __le32_to_cpu(val) #define snd_LE_to_host_32(val) __le32_to_cpu(val)
/** convert 16-bit value from host to Big Endian byte order */
#define snd_host_to_BE_16(val) __cpu_to_be16(val) #define snd_host_to_BE_16(val) __cpu_to_be16(val)
/** convert 16-bit value from Big Endian to host byte order */
#define snd_BE_to_host_16(val) __be16_to_cpu(val) #define snd_BE_to_host_16(val) __be16_to_cpu(val)
/** convert 32-bit value from host to Big Endian byte order */
#define snd_host_to_BE_32(val) __cpu_to_be32(val) #define snd_host_to_BE_32(val) __cpu_to_be32(val)
/** convert 32-bit value from Big Endian to host byte order */
#define snd_BE_to_host_32(val) __be32_to_cpu(val) #define snd_BE_to_host_32(val) __be32_to_cpu(val)
/** \} */ /** \} */

4
include/error.h
View file

@ -4,8 +4,8 @@
* \{ * \{
*/ */
#define SND_ERROR_BEGIN 500000 #define SND_ERROR_BEGIN 500000 /**< begin boundary of sound error codes */
#define SND_ERROR_INCOMPATIBLE_VERSION (SND_ERROR_BEGIN+0) #define SND_ERROR_INCOMPATIBLE_VERSION (SND_ERROR_BEGIN+0) /**< protocol is not compatible */
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {

4
include/global.h
View file

@ -12,10 +12,6 @@
#define SND_BIG_ENDIAN SNDRV_BIG_ENDIAN #define SND_BIG_ENDIAN SNDRV_BIG_ENDIAN
#endif #endif
#define snd_enum_to_int(v) (v)
#define snd_int_to_enum(v) (v)
#define snd_enum_incr(v) (++(v))
/** \} */ /** \} */
/** Async notification client handler */ /** Async notification client handler */

10
include/header.h
View file

@ -39,14 +39,14 @@
#include <errno.h> #include <errno.h>
#ifndef ATTRIBUTE_UNUSED #ifndef ATTRIBUTE_UNUSED
#define ATTRIBUTE_UNUSED __attribute__ ((__unused__)) #define ATTRIBUTE_UNUSED __attribute__ ((__unused__)) /**< don't print warning when attribute is not used */
#endif #endif
#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 95) #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 95)
#define SNDERR(...) snd_lib_error(__FILE__, __LINE__, __FUNCTION__, 0, __VA_ARGS__) #define SNDERR(...) snd_lib_error(__FILE__, __LINE__, __FUNCTION__, 0, __VA_ARGS__) /**< show sound error */
#define SYSERR(...) snd_lib_error(__FILE__, __LINE__, __FUNCTION__, errno, __VA_ARGS__) #define SYSERR(...) snd_lib_error(__FILE__, __LINE__, __FUNCTION__, errno, __VA_ARGS__) /**< show system error */
#else #else
#define SNDERR(args...) snd_lib_error(__FILE__, __LINE__, __FUNCTION__, 0, ##args) #define SNDERR(args...) snd_lib_error(__FILE__, __LINE__, __FUNCTION__, 0, ##args) /**< show sound error */
#define SYSERR(args...) snd_lib_error(__FILE__, __LINE__, __FUNCTION__, errno, ##args) #define SYSERR(args...) snd_lib_error(__FILE__, __LINE__, __FUNCTION__, errno, ##args) /**< show system error */
#endif #endif

60
include/instr.h
View file

@ -25,7 +25,7 @@ do {\
assert(ptr);\ assert(ptr);\
*ptr = (snd_instr_header_t *)alloca(snd_instr_header_sizeof());\ *ptr = (snd_instr_header_t *)alloca(snd_instr_header_sizeof());\
memset(*ptr, 0, snd_instr_header_sizeof());\ memset(*ptr, 0, snd_instr_header_sizeof());\
} while (0) } while (0) /**< allocate instrument header on stack */
int snd_instr_header_malloc(snd_instr_header_t **ptr, size_t len); int snd_instr_header_malloc(snd_instr_header_t **ptr, size_t len);
void snd_instr_header_free(snd_instr_header_t *ptr); void snd_instr_header_free(snd_instr_header_t *ptr);
void snd_instr_header_copy(snd_instr_header_t *dst, const snd_instr_header_t *src); void snd_instr_header_copy(snd_instr_header_t *dst, const snd_instr_header_t *src);
@ -61,45 +61,45 @@ void snd_instr_header_set_follow_alias(snd_instr_header_t *info, int val);
*/ */
/** instrument types */ /** instrument types */
#define SND_SEQ_INSTR_ATYPE_DATA 0 /**< instrument data */ #define SND_SEQ_INSTR_ATYPE_DATA SNDRV_SEQ_INSTR_ATYPE_DATA /**< instrument data */
#define SND_SEQ_INSTR_ATYPE_ALIAS 1 /**< instrument alias */ #define SND_SEQ_INSTR_ATYPE_ALIAS SNDRV_SEQ_INSTR_ATYPE_ALIAS /**< instrument alias */
/** instrument ASCII identifiers */ /** instrument ASCII identifiers */
#define SND_SEQ_INSTR_ID_DLS1 "DLS1" /**< DLS1 */ #define SND_SEQ_INSTR_ID_DLS1 SNDRV_SEQ_INSTR_ID_DLS1 /**< DLS1 */
#define SND_SEQ_INSTR_ID_DLS2 "DLS2" /**< DLS2 */ #define SND_SEQ_INSTR_ID_DLS2 SNDRV_SEQ_INSTR_ID_DLS2 /**< DLS2 */
#define SND_SEQ_INSTR_ID_SIMPLE "Simple Wave" /**< Simple Wave */ #define SND_SEQ_INSTR_ID_SIMPLE SNDRV_SEQ_INSTR_ID_SIMPLE /**< Simple Wave */
#define SND_SEQ_INSTR_ID_SOUNDFONT "SoundFont" /**< SoundFont */ #define SND_SEQ_INSTR_ID_SOUNDFONT SNDRV_SEQ_INSTR_ID_SOUNDFONT /**< SoundFont */
#define SND_SEQ_INSTR_ID_GUS_PATCH "GUS Patch" /**< Gravis Patch */ #define SND_SEQ_INSTR_ID_GUS_PATCH SNDRV_SEQ_INSTR_ID_GUS_PATCH /**< Gravis Patch */
#define SND_SEQ_INSTR_ID_INTERWAVE "InterWave FFFF" /**< InterWave FFFF */ #define SND_SEQ_INSTR_ID_INTERWAVE SNDRV_SEQ_INSTR_ID_INTERWAVE /**< InterWave FFFF */
#define SND_SEQ_INSTR_ID_OPL2_3 "OPL2/3 FM" /**< OPL2/3 FM */ #define SND_SEQ_INSTR_ID_OPL2_3 SNDRV_SEQ_INSTR_ID_OPL2_3 /**< OPL2/3 FM */
#define SND_SEQ_INSTR_ID_OPL4 "OPL4" /**< OPL4 */ #define SND_SEQ_INSTR_ID_OPL4 SNDRV_SEQ_INSTR_ID_OPL4 /**< OPL4 */
/** instrument types */ /** instrument types */
#define SND_SEQ_INSTR_TYPE0_DLS1 (1<<0) /**< MIDI DLS v1 */ #define SND_SEQ_INSTR_TYPE0_DLS1 SNDRV_SEQ_INSTR_TYPE0_DLS1 /**< MIDI DLS v1 */
#define SND_SEQ_INSTR_TYPE0_DLS2 (1<<1) /**< MIDI DLS v2 */ #define SND_SEQ_INSTR_TYPE0_DLS2 SNDRV_SEQ_INSTR_TYPE0_DLS2 /**< MIDI DLS v2 */
#define SND_SEQ_INSTR_TYPE1_SIMPLE (1<<0) /**< Simple Wave */ #define SND_SEQ_INSTR_TYPE1_SIMPLE SNDRV_SEQ_INSTR_TYPE1_SIMPLE /**< Simple Wave */
#define SND_SEQ_INSTR_TYPE1_SOUNDFONT (1<<1) /**< EMU SoundFont */ #define SND_SEQ_INSTR_TYPE1_SOUNDFONT SNDRV_SEQ_INSTR_TYPE1_SOUNDFONT /**< EMU SoundFont */
#define SND_SEQ_INSTR_TYPE1_GUS_PATCH (1<<2) /**< Gravis UltraSound Patch */ #define SND_SEQ_INSTR_TYPE1_GUS_PATCH SNDRV_SEQ_INSTR_TYPE1_GUS_PATCH /**< Gravis UltraSound Patch */
#define SND_SEQ_INSTR_TYPE1_INTERWAVE (1<<3) /**< InterWave FFFF */ #define SND_SEQ_INSTR_TYPE1_INTERWAVE SNDRV_SEQ_INSTR_TYPE1_INTERWAVE /**< InterWave FFFF */
#define SND_SEQ_INSTR_TYPE2_OPL2_3 (1<<0) /**< Yamaha OPL2/3 FM */ #define SND_SEQ_INSTR_TYPE2_OPL2_3 SNDRV_SEQ_INSTR_TYPE2_OPL2_3 /**< Yamaha OPL2/3 FM */
#define SND_SEQ_INSTR_TYPE2_OPL4 (1<<1) /**< Yamaha OPL4 */ #define SND_SEQ_INSTR_TYPE2_OPL4 SNDRV_SEQ_INSTR_TYPE2_OPL4 /**< Yamaha OPL4 */
/** put commands */ /** put commands */
#define SND_SEQ_INSTR_PUT_CMD_CREATE 0 /**< create a new layer */ #define SND_SEQ_INSTR_PUT_CMD_CREATE SNDRV_SEQ_INSTR_PUT_CMD_CREATE /**< 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_REPLACE SNDRV_SEQ_INSTR_PUT_CMD_REPLACE /**< 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_MODIFY SNDRV_SEQ_INSTR_PUT_CMD_MODIFY /**< modify the existing layer */
#define SND_SEQ_INSTR_PUT_CMD_ADD 3 /**< add one to 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 4 /**< remove the layer */ #define SND_SEQ_INSTR_PUT_CMD_REMOVE SNDRV_SEQ_INSTR_PUT_CMD_REMOVE /**< remove the layer */
/** get commands */ /** get commands */
#define SND_SEQ_INSTR_GET_CMD_FULL 0 /**< get the full data stream */ #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 1 /**< get the partial data stream */ #define SND_SEQ_INSTR_GET_CMD_PARTIAL SNDRV_SEQ_INSTR_GET_CMD_PARTIAL /**< get the partial data stream */
/** free commands */ /** free commands */
#define SND_SEQ_INSTR_FREE_CMD_ALL 0 /**< remove all matching instruments */ #define SND_SEQ_INSTR_FREE_CMD_ALL SNDRV_SEQ_INSTR_FREE_CMD_ALL /**< remove all matching instruments */
#define SND_SEQ_INSTR_FREE_CMD_PRIVATE 1 /**< remove only private 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 2 /**< remove only cluster 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 3 /**< remove single instrument */ #define SND_SEQ_INSTR_FREE_CMD_SINGLE SNDRV_SEQ_INSTR_FREE_CMD_SINGLE /**< remove single instrument */
/** /**

13
include/pcm.h
View file

@ -209,18 +209,31 @@ typedef sndrv_pcm_sframes_t snd_pcm_sframes_t;
/** Timestamp */ /** Timestamp */
typedef struct timeval snd_timestamp_t; typedef struct timeval snd_timestamp_t;
/** device accepts mmaped access */
#define SND_PCM_INFO_MMAP SNDRV_PCM_INFO_MMAP #define SND_PCM_INFO_MMAP SNDRV_PCM_INFO_MMAP
/** device accepts mmaped access with sample resolution */
#define SND_PCM_INFO_MMAP_VALID SNDRV_PCM_INFO_MMAP_VALID #define SND_PCM_INFO_MMAP_VALID SNDRV_PCM_INFO_MMAP_VALID
/** device is doing double buffering */
#define SND_PCM_INFO_DOUBLE SNDRV_PCM_INFO_DOUBLE #define SND_PCM_INFO_DOUBLE SNDRV_PCM_INFO_DOUBLE
/** device transfers samples in batch */
#define SND_PCM_INFO_BATCH SNDRV_PCM_INFO_BATCH #define SND_PCM_INFO_BATCH SNDRV_PCM_INFO_BATCH
/** device accepts interleaved samples */
#define SND_PCM_INFO_INTERLEAVED SNDRV_PCM_INFO_INTERLEAVED #define SND_PCM_INFO_INTERLEAVED SNDRV_PCM_INFO_INTERLEAVED
/** device accepts non-interleaved samples */
#define SND_PCM_INFO_NONINTERLEAVED SNDRV_PCM_INFO_NONINTERLEAVED #define SND_PCM_INFO_NONINTERLEAVED SNDRV_PCM_INFO_NONINTERLEAVED
/** device accepts complex sample organization */
#define SND_PCM_INFO_COMPLEX SNDRV_PCM_INFO_COMPLEX #define SND_PCM_INFO_COMPLEX SNDRV_PCM_INFO_COMPLEX
/** device is capable block transfers */
#define SND_PCM_INFO_BLOCK_TRANSFER SNDRV_PCM_INFO_BLOCK_TRANSFER #define SND_PCM_INFO_BLOCK_TRANSFER SNDRV_PCM_INFO_BLOCK_TRANSFER
/** device can detect DAC/ADC overrange */
#define SND_PCM_INFO_OVERRANGE SNDRV_PCM_INFO_OVERRANGE #define SND_PCM_INFO_OVERRANGE SNDRV_PCM_INFO_OVERRANGE
/** device is capable to pause */
#define SND_PCM_INFO_PAUSE SNDRV_PCM_INFO_PAUSE #define SND_PCM_INFO_PAUSE SNDRV_PCM_INFO_PAUSE
/** device can do only half duplex */
#define SND_PCM_INFO_HALF_DUPLEX SNDRV_PCM_INFO_HALF_DUPLEX #define SND_PCM_INFO_HALF_DUPLEX SNDRV_PCM_INFO_HALF_DUPLEX
/** device can do only joint duplex (same parameters) */
#define SND_PCM_INFO_JOINT_DUPLEX SNDRV_PCM_INFO_JOINT_DUPLEX #define SND_PCM_INFO_JOINT_DUPLEX SNDRV_PCM_INFO_JOINT_DUPLEX
/** device can do a kind of synchronized start */
#define SND_PCM_INFO_SYNC_START SNDRV_PCM_INFO_SYNC_START #define SND_PCM_INFO_SYNC_START SNDRV_PCM_INFO_SYNC_START
/** Non blocking mode \hideinitializer */ /** Non blocking mode \hideinitializer */

8
src/conf.c
View file

@ -874,7 +874,7 @@ static int _snd_config_save_leaf(snd_config_t *n, snd_output_t *out,
{ {
int err; int err;
unsigned int k; unsigned int k;
switch (snd_enum_to_int(n->type)) { switch (n->type) {
case SND_CONFIG_TYPE_INTEGER: case SND_CONFIG_TYPE_INTEGER:
snd_output_printf(out, "%ld", n->u.integer); snd_output_printf(out, "%ld", n->u.integer);
break; break;
@ -1149,7 +1149,7 @@ int snd_config_remove(snd_config_t *config)
int snd_config_delete(snd_config_t *config) int snd_config_delete(snd_config_t *config)
{ {
assert(config); assert(config);
switch (snd_enum_to_int(config->type)) { switch (config->type) {
case SND_CONFIG_TYPE_COMPOUND: case SND_CONFIG_TYPE_COMPOUND:
{ {
int err; int err;
@ -1309,7 +1309,7 @@ int snd_config_set_string(snd_config_t *config, const char *value)
int snd_config_set_ascii(snd_config_t *config, const char *ascii) int snd_config_set_ascii(snd_config_t *config, const char *ascii)
{ {
assert(config && ascii); assert(config && ascii);
switch (snd_enum_to_int(config->type)) { switch (config->type) {
case SND_CONFIG_TYPE_INTEGER: case SND_CONFIG_TYPE_INTEGER:
{ {
long i; long i;
@ -1396,7 +1396,7 @@ int snd_config_get_string(snd_config_t *config, const char **ptr)
int snd_config_get_ascii(snd_config_t *config, char **ascii) int snd_config_get_ascii(snd_config_t *config, char **ascii)
{ {
assert(config && ascii); assert(config && ascii);
switch (snd_enum_to_int(config->type)) { switch (config->type) {
case SND_CONFIG_TYPE_INTEGER: case SND_CONFIG_TYPE_INTEGER:
{ {
char res[12]; char res[12];

32
src/control/control.c
View file

@ -437,8 +437,8 @@ snd_ctl_t *snd_async_handler_get_ctl(snd_async_handler_t *handler)
return handler->u.ctl; return handler->u.ctl;
} }
int snd_ctl_open_conf(snd_ctl_t **ctlp, const char *name, static int snd_ctl_open_conf(snd_ctl_t **ctlp, const char *name,
snd_config_t *ctl_root, snd_config_t *ctl_conf, int mode) snd_config_t *ctl_root, snd_config_t *ctl_conf, int mode)
{ {
const char *str; const char *str;
char buf[256]; char buf[256];
@ -520,7 +520,7 @@ int snd_ctl_open_conf(snd_ctl_t **ctlp, const char *name,
return err >= 0 ? open_func(ctlp, name, ctl_root, ctl_conf, mode) : err; return err >= 0 ? open_func(ctlp, name, ctl_root, ctl_conf, mode) : err;
} }
int snd_ctl_open_noupdate(snd_ctl_t **ctlp, snd_config_t *root, const char *name, int mode) static int snd_ctl_open_noupdate(snd_ctl_t **ctlp, snd_config_t *root, const char *name, int mode)
{ {
int err; int err;
snd_config_t *ctl_conf; snd_config_t *ctl_conf;
@ -604,7 +604,7 @@ static const char *snd_ctl_event_type_names[] = {
const char *snd_ctl_elem_type_name(snd_ctl_elem_type_t type) const char *snd_ctl_elem_type_name(snd_ctl_elem_type_t type)
{ {
assert(type <= SND_CTL_ELEM_TYPE_LAST); assert(type <= SND_CTL_ELEM_TYPE_LAST);
return snd_ctl_elem_type_names[snd_enum_to_int(type)]; return snd_ctl_elem_type_names[type];
} }
/** /**
@ -615,7 +615,7 @@ const char *snd_ctl_elem_type_name(snd_ctl_elem_type_t type)
const char *snd_ctl_elem_iface_name(snd_ctl_elem_iface_t iface) const char *snd_ctl_elem_iface_name(snd_ctl_elem_iface_t iface)
{ {
assert(iface <= SND_CTL_ELEM_IFACE_LAST); assert(iface <= SND_CTL_ELEM_IFACE_LAST);
return snd_ctl_elem_iface_names[snd_enum_to_int(iface)]; return snd_ctl_elem_iface_names[iface];
} }
/** /**
@ -626,7 +626,7 @@ const char *snd_ctl_elem_iface_name(snd_ctl_elem_iface_t iface)
const char *snd_ctl_event_type_name(snd_ctl_event_type_t type) const char *snd_ctl_event_type_name(snd_ctl_event_type_t type)
{ {
assert(type <= SND_CTL_EVENT_LAST); assert(type <= SND_CTL_EVENT_LAST);
return snd_ctl_event_type_names[snd_enum_to_int(type)]; return snd_ctl_event_type_names[type];
} }
/** /**
@ -703,7 +703,7 @@ snd_ctl_elem_iface_t snd_ctl_event_elem_get_interface(const snd_ctl_event_t *obj
{ {
assert(obj); assert(obj);
assert(obj->type == SND_CTL_EVENT_ELEM); assert(obj->type == SND_CTL_EVENT_ELEM);
return snd_int_to_enum(obj->data.elem.id.iface); return obj->data.elem.id.iface;
} }
/** /**
@ -833,7 +833,7 @@ unsigned int snd_ctl_elem_id_get_numid(const snd_ctl_elem_id_t *obj)
snd_ctl_elem_iface_t snd_ctl_elem_id_get_interface(const snd_ctl_elem_id_t *obj) snd_ctl_elem_iface_t snd_ctl_elem_id_get_interface(const snd_ctl_elem_id_t *obj)
{ {
assert(obj); assert(obj);
return snd_int_to_enum(obj->iface); return obj->iface;
} }
/** /**
@ -899,7 +899,7 @@ void snd_ctl_elem_id_set_numid(snd_ctl_elem_id_t *obj, unsigned int val)
void snd_ctl_elem_id_set_interface(snd_ctl_elem_id_t *obj, snd_ctl_elem_iface_t val) void snd_ctl_elem_id_set_interface(snd_ctl_elem_id_t *obj, snd_ctl_elem_iface_t val)
{ {
assert(obj); assert(obj);
obj->iface = snd_enum_to_int(val); obj->iface = val;
} }
/** /**
@ -1135,7 +1135,7 @@ void snd_ctl_event_copy(snd_ctl_event_t *dst, const snd_ctl_event_t *src)
snd_ctl_event_type_t snd_ctl_event_get_type(const snd_ctl_event_t *obj) snd_ctl_event_type_t snd_ctl_event_get_type(const snd_ctl_event_t *obj)
{ {
assert(obj); assert(obj);
return snd_int_to_enum(obj->type); return obj->type;
} }
/** /**
@ -1259,7 +1259,7 @@ snd_ctl_elem_iface_t snd_ctl_elem_list_get_interface(const snd_ctl_elem_list_t *
{ {
assert(obj); assert(obj);
assert(idx < obj->used); assert(idx < obj->used);
return snd_int_to_enum(obj->pids[idx].iface); return obj->pids[idx].iface;
} }
/** /**
@ -1374,7 +1374,7 @@ void snd_ctl_elem_info_copy(snd_ctl_elem_info_t *dst, const snd_ctl_elem_info_t
snd_ctl_elem_type_t snd_ctl_elem_info_get_type(const snd_ctl_elem_info_t *obj) snd_ctl_elem_type_t snd_ctl_elem_info_get_type(const snd_ctl_elem_info_t *obj)
{ {
assert(obj); assert(obj);
return snd_int_to_enum(obj->type); return obj->type;
} }
/** /**
@ -1577,7 +1577,7 @@ unsigned int snd_ctl_elem_info_get_numid(const snd_ctl_elem_info_t *obj)
snd_ctl_elem_iface_t snd_ctl_elem_info_get_interface(const snd_ctl_elem_info_t *obj) snd_ctl_elem_iface_t snd_ctl_elem_info_get_interface(const snd_ctl_elem_info_t *obj)
{ {
assert(obj); assert(obj);
return snd_int_to_enum(obj->id.iface); return obj->id.iface;
} }
/** /**
@ -1654,7 +1654,7 @@ void snd_ctl_elem_info_set_numid(snd_ctl_elem_info_t *obj, unsigned int val)
void snd_ctl_elem_info_set_interface(snd_ctl_elem_info_t *obj, snd_ctl_elem_iface_t val) void snd_ctl_elem_info_set_interface(snd_ctl_elem_info_t *obj, snd_ctl_elem_iface_t val)
{ {
assert(obj); assert(obj);
obj->id.iface = snd_enum_to_int(val); obj->id.iface = val;
} }
/** /**
@ -1783,7 +1783,7 @@ unsigned int snd_ctl_elem_value_get_numid(const snd_ctl_elem_value_t *obj)
snd_ctl_elem_iface_t snd_ctl_elem_value_get_interface(const snd_ctl_elem_value_t *obj) snd_ctl_elem_iface_t snd_ctl_elem_value_get_interface(const snd_ctl_elem_value_t *obj)
{ {
assert(obj); assert(obj);
return snd_int_to_enum(obj->id.iface); return obj->id.iface;
} }
/** /**
@ -1860,7 +1860,7 @@ void snd_ctl_elem_value_set_numid(snd_ctl_elem_value_t *obj, unsigned int val)
void snd_ctl_elem_value_set_interface(snd_ctl_elem_value_t *obj, snd_ctl_elem_iface_t val) void snd_ctl_elem_value_set_interface(snd_ctl_elem_value_t *obj, snd_ctl_elem_iface_t val)
{ {
assert(obj); assert(obj);
obj->id.iface = snd_enum_to_int(val); obj->id.iface = val;
} }
/** /**

6
src/control/hcontrol.c
View file

@ -35,10 +35,14 @@
#include <string.h> #include <string.h>
#include <fcntl.h> #include <fcntl.h>
#include <sys/ioctl.h> #include <sys/ioctl.h>
#ifndef DOC_HIDDEN
#define __USE_GNU #define __USE_GNU
#endif
#include "control_local.h" #include "control_local.h"
#ifndef DOC_HIDDEN
#define NOT_FOUND 1000000000 #define NOT_FOUND 1000000000
#endif
static int snd_hctl_compare_default(const snd_hctl_elem_t *c1, static int snd_hctl_compare_default(const snd_hctl_elem_t *c1,
const snd_hctl_elem_t *c2); const snd_hctl_elem_t *c2);
@ -776,7 +780,7 @@ unsigned int snd_hctl_elem_get_numid(const snd_hctl_elem_t *obj)
snd_ctl_elem_iface_t snd_hctl_elem_get_interface(const snd_hctl_elem_t *obj) snd_ctl_elem_iface_t snd_hctl_elem_get_interface(const snd_hctl_elem_t *obj)
{ {
assert(obj); assert(obj);
return snd_int_to_enum(obj->id.iface); return obj->id.iface;
} }
/** /**

10
src/control/setup.c
View file

@ -196,7 +196,7 @@ static int snd_config_get_ctl_elem_enumerated(snd_config_t *n, snd_ctl_t *ctl,
const char *str; const char *str;
long val; long val;
unsigned int idx, items; unsigned int idx, items;
switch (snd_enum_to_int(snd_config_get_type(n))) { switch (snd_config_get_type(n)) {
case SND_CONFIG_TYPE_INTEGER: case SND_CONFIG_TYPE_INTEGER:
snd_config_get_integer(n, &val); snd_config_get_integer(n, &val);
return val; return val;
@ -239,7 +239,7 @@ static int snd_config_get_ctl_elem_value(snd_config_t *conf,
count = snd_ctl_elem_info_get_count(info); count = snd_ctl_elem_info_get_count(info);
type = snd_ctl_elem_info_get_type(info); type = snd_ctl_elem_info_get_type(info);
if (count == 1) { if (count == 1) {
switch (snd_enum_to_int(type)) { switch (type) {
case SND_CTL_ELEM_TYPE_BOOLEAN: case SND_CTL_ELEM_TYPE_BOOLEAN:
v = snd_config_get_bool(conf); v = snd_config_get_bool(conf);
if (v >= 0) { if (v >= 0) {
@ -271,11 +271,11 @@ static int snd_config_get_ctl_elem_value(snd_config_t *conf,
case SND_CTL_ELEM_TYPE_IEC958: case SND_CTL_ELEM_TYPE_IEC958:
break; break;
default: default:
SNDERR("Unknow control type: %d", snd_enum_to_int(type)); SNDERR("Unknow control type: %d", type);
return -EINVAL; return -EINVAL;
} }
} }
switch (snd_enum_to_int(type)) { switch (type) {
case SND_CTL_ELEM_TYPE_IEC958: case SND_CTL_ELEM_TYPE_IEC958:
count = sizeof(snd_aes_iec958_t); count = sizeof(snd_aes_iec958_t);
/* Fall through */ /* Fall through */
@ -329,7 +329,7 @@ static int snd_config_get_ctl_elem_value(snd_config_t *conf,
SNDERR("bad value index"); SNDERR("bad value index");
return -EINVAL; return -EINVAL;
} }
switch (snd_enum_to_int(type)) { switch (type) {
case SND_CTL_ELEM_TYPE_BOOLEAN: case SND_CTL_ELEM_TYPE_BOOLEAN:
v = snd_config_get_bool(n); v = snd_config_get_bool(n);
if (v < 0) if (v < 0)

2
src/hwdep/hwdep_m4.c
View file

@ -73,7 +73,7 @@ const char *snd_hwdep_info_get_name(const snd_hwdep_info_t *obj)
snd_hwdep_iface_t snd_hwdep_info_get_iface(const snd_hwdep_info_t *obj) snd_hwdep_iface_t snd_hwdep_info_get_iface(const snd_hwdep_info_t *obj)
{ {
assert(obj); assert(obj);
return snd_int_to_enum(obj->iface); return obj->iface;
} }
void snd_hwdep_info_set_device(snd_hwdep_info_t *obj, unsigned int val) void snd_hwdep_info_set_device(snd_hwdep_info_t *obj, unsigned int val)

25
src/instr/fm.c
View file

@ -1,3 +1,8 @@
/**
* \file src/instr/fm.c
* \author Uros Bizjak <uros@kss-loka.si>
* \date 2000-2001
*/
/* /*
* FM (OPL2/3) Instrument Format Support * FM (OPL2/3) Instrument Format Support
* Copyright (c) 2000 Uros Bizjak <uros@kss-loka.si> * Copyright (c) 2000 Uros Bizjak <uros@kss-loka.si>
@ -27,6 +32,11 @@
#include <asm/byteorder.h> #include <asm/byteorder.h>
#include <sound/ainstr_fm.h> #include <sound/ainstr_fm.h>
/**
* \brief Free the FM instrument handle
* \param fm FM instrument handle
* \return 0 on success otherwise a negative error code
*/
int snd_instr_fm_free(snd_instr_fm_t *fm) int snd_instr_fm_free(snd_instr_fm_t *fm)
{ {
if (fm == NULL) if (fm == NULL)
@ -35,6 +45,14 @@ int snd_instr_fm_free(snd_instr_fm_t *fm)
return 0; return 0;
} }
/**
* \brief Convert the FM instrument to byte stream
* \param fm FM instrument handle
* \param name FM instrument name
* \param __data Result - allocated byte stream
* \param __size Result - size of allocated byte stream
* \return 0 on success otherwise a negative error code
*/
int snd_instr_fm_convert_to_stream(snd_instr_fm_t *fm, int snd_instr_fm_convert_to_stream(snd_instr_fm_t *fm,
const char *name, const char *name,
snd_instr_header_t **__data, snd_instr_header_t **__data,
@ -89,6 +107,13 @@ int snd_instr_fm_convert_to_stream(snd_instr_fm_t *fm,
return 0; return 0;
} }
/**
* \brief Convert the byte stream to FM instrument
* \param __data Input - byte stream containing FM instrument definition
* \param size Input - size of byte stream
* \param simple Result - allocated FM instrument handle
* \return 0 on success otherwise a negative error code
*/
int snd_instr_fm_convert_from_stream(snd_instr_header_t *__data ATTRIBUTE_UNUSED, int snd_instr_fm_convert_from_stream(snd_instr_header_t *__data ATTRIBUTE_UNUSED,
size_t size ATTRIBUTE_UNUSED, size_t size ATTRIBUTE_UNUSED,
snd_instr_fm_t **simple ATTRIBUTE_UNUSED) snd_instr_fm_t **simple ATTRIBUTE_UNUSED)

101
src/instr/iwffff.c
View file

@ -1,3 +1,8 @@
/**
* \file src/instr/iwffff.c
* \author Jaroslav Kysela <perex@suse.cz>
* \date 1999-2001
*/
/* /*
* InterWave FFFF Format Support * InterWave FFFF Format Support
* Copyright (c) 1999 by Jaroslav Kysela <perex@suse.cz> * Copyright (c) 1999 by Jaroslav Kysela <perex@suse.cz>
@ -31,6 +36,8 @@
* defines * defines
*/ */
#ifndef DOC_HIDDEN
#define IW_RAM_FILE "/proc/asound/%i/gus-ram-%i" #define IW_RAM_FILE "/proc/asound/%i/gus-ram-%i"
#define IW_ROM_FILE "/proc/asound/%i/gus-rom-%i" #define IW_ROM_FILE "/proc/asound/%i/gus-rom-%i"
@ -182,6 +189,8 @@ struct _snd_iwffff_handle {
unsigned int share_id3; unsigned int share_id3;
}; };
#endif /* DOC_HIDDEN */
/* /*
* local functions * local functions
*/ */
@ -201,6 +210,13 @@ static int iwffff_get_rom_header(int card, int bank, iwffff_rom_header_t *header
return fd; return fd;
} }
/**
* \brief Open IWFFFF files
* \param handle IWFFFF handle
* \param name_fff filename of an FFF (header) file
* \param name_dat filename of an DAT (data) file
* \return 0 on success otherwise a negative error code
*/
int snd_instr_iwffff_open(snd_iwffff_handle_t **handle, const char *name_fff, const char *name_dat) int snd_instr_iwffff_open(snd_iwffff_handle_t **handle, const char *name_fff, const char *name_dat)
{ {
snd_iwffff_handle_t *iwf; snd_iwffff_handle_t *iwf;
@ -253,6 +269,14 @@ int snd_instr_iwffff_open(snd_iwffff_handle_t **handle, const char *name_fff, co
return 0; return 0;
} }
/**
* \brief Open IWFFFF ROM
* \param handle IWFFFF handle
* \param card card number
* \param bank ROM bank number (0-3)
* \param file ROM file number
* \return 0 on success otherwise a negative error code
*/
int snd_instr_iwffff_open_rom(snd_iwffff_handle_t **handle, int card, int bank, int file) int snd_instr_iwffff_open_rom(snd_iwffff_handle_t **handle, int card, int bank, int file)
{ {
unsigned int next_ffff; unsigned int next_ffff;
@ -265,7 +289,7 @@ int snd_instr_iwffff_open_rom(snd_iwffff_handle_t **handle, int card, int bank,
return -EINVAL; return -EINVAL;
*handle = NULL; *handle = NULL;
idx = 0; idx = 0;
if (bank > 4 || file > 255) if (bank > 3 || file > 255)
return -1; return -1;
fd = iwffff_get_rom_header(card, bank, &header); fd = iwffff_get_rom_header(card, bank, &header);
if (fd < 0) if (fd < 0)
@ -310,17 +334,36 @@ int snd_instr_iwffff_open_rom(snd_iwffff_handle_t **handle, int card, int bank,
return -ENOENT; return -ENOENT;
} }
int snd_instr_iwffff_close(snd_iwffff_handle_t *iwf) /**
* \brief Open IWFFFF ROM file
* \param handle IWFFFF handle
* \param name IWFFFF ROM filename
* \param bank ROM bank number (0-3)
* \param file ROM file number
* \return 0 on success otherwise a negative error code
*/
int snd_instr_iwffff_open_rom_file(snd_iwffff_handle_t **handle ATTRIBUTE_UNUSED, const char *name ATTRIBUTE_UNUSED, int bank ATTRIBUTE_UNUSED, int file ATTRIBUTE_UNUSED)
{ {
if (iwf == NULL) /* TODO */
return -ENXIO;
}
/**
* \brief Close and free IWFFFF handle
* \param handle IWFFFF handle
* \return 0 on success otherwise a negative error code
*/
int snd_instr_iwffff_close(snd_iwffff_handle_t *handle)
{
if (handle == NULL)
return -EINVAL; return -EINVAL;
if (iwf->dat_filename) if (handle->dat_filename)
free(iwf->dat_filename); free(handle->dat_filename);
if (iwf->fff_filename) if (handle->fff_filename)
free(iwf->fff_filename); free(handle->fff_filename);
if (iwf->fff_data) if (handle->fff_data)
free(iwf->fff_data); free(handle->fff_data);
free(iwf); free(handle);
return 0; return 0;
} }
@ -368,6 +411,11 @@ static void free_layer(iwffff_layer_t *layer)
free(layer); free(layer);
} }
/**
* \brief Free IWFFFF instrument
* \param __instr IWFFFF instrument handle
* \return 0 on success otherwise a negative error code
*/
int snd_instr_iwffff_free(snd_instr_iwffff_t *__instr) int snd_instr_iwffff_free(snd_instr_iwffff_t *__instr)
{ {
iwffff_instrument_t *instr = (iwffff_instrument_t *)__instr; iwffff_instrument_t *instr = (iwffff_instrument_t *)__instr;
@ -401,7 +449,7 @@ static char *look_for_id(snd_iwffff_handle_t *iwf ATTRIBUTE_UNUSED, unsigned cha
static void copy_modulation(iwffff_lfo_t *glfo, unsigned char *buffer) static void copy_modulation(iwffff_lfo_t *glfo, unsigned char *buffer)
{ {
glfo->freq = snd_LE_to_host_16(*(((unsigned short *)buffer) + 0/2)); glfo->freq = snd_LE_to_host_16(*(((unsigned short *)buffer) + 0/2));
glfo->depth = snd_LE_to_host_16(*(((unsigned short *)buffer) + 2/1)); glfo->depth = snd_LE_to_host_16(*(((unsigned short *)buffer) + 2/2));
glfo->sweep = snd_LE_to_host_16(*(((unsigned short *)buffer) + 4/2)); glfo->sweep = snd_LE_to_host_16(*(((unsigned short *)buffer) + 4/2));
glfo->shape = buffer[6]; glfo->shape = buffer[6];
glfo->delay = buffer[7]; glfo->delay = buffer[7];
@ -607,6 +655,14 @@ static int load_iw_patch(snd_iwffff_handle_t *iwf, iwffff_instrument_t *instr,
return 0; return 0;
} }
/**
* \brief Load IWFFFF instrument
* \param iwf IWFFFF handle
* \param bank program bank number
* \param prg program number
* \param __iwffff allocated IWFFFF instrument
* \return 0 on success otherwise a negative error code
*/
int snd_instr_iwffff_load(snd_iwffff_handle_t *iwf, int bank, int prg, snd_instr_iwffff_t **__iwffff) int snd_instr_iwffff_load(snd_iwffff_handle_t *iwf, int bank, int prg, snd_instr_iwffff_t **__iwffff)
{ {
unsigned char *ptr, *end; unsigned char *ptr, *end;
@ -738,10 +794,18 @@ static int copy_env_to_stream(iwffff_xenv_t *xenv, iwffff_env_t *env, __u32 styp
return size; return size;
} }
int snd_instr_iwffff_conv_to_stream(snd_instr_iwffff_t *iwffff, /**
const char *name, * \brief Convert the IWFFFF instrument to byte stream
snd_instr_header_t **__data, * \param iwffff IWFFFF instrument handle
long *__size) * \param name instrument name
* \param __data Result - allocated byte stream
* \param __size Result - size of allocated byte stream
* \return 0 on success otherwise a negative error code
*/
int snd_instr_iwffff_convert_to_stream(snd_instr_iwffff_t *iwffff,
const char *name,
snd_instr_header_t **__data,
size_t *__size)
{ {
snd_instr_header_t *put; snd_instr_header_t *put;
int size; int size;
@ -827,6 +891,13 @@ int snd_instr_iwffff_conv_to_stream(snd_instr_iwffff_t *iwffff,
return 0; return 0;
} }
/**
* \brief Convert the byte stream to IWFFFF instrument
* \param data Input - byte stream
* \param size Input - size of byte stream
* \param iwffff Result - allocated IWFFFF instrument handle
* \return 0 on success otherwise a negative error code
*/
int snd_instr_iwffff_convert_from_stream(snd_instr_header_t *data ATTRIBUTE_UNUSED, int snd_instr_iwffff_convert_from_stream(snd_instr_header_t *data ATTRIBUTE_UNUSED,
size_t size ATTRIBUTE_UNUSED, size_t size ATTRIBUTE_UNUSED,
snd_instr_iwffff_t **iwffff ATTRIBUTE_UNUSED) snd_instr_iwffff_t **iwffff ATTRIBUTE_UNUSED)

25
src/instr/simple.c
View file

@ -1,3 +1,8 @@
/**
* \file src/instr/simple.c
* \author Jaroslav Kysela <perex@suse.cz>
* \date 1999-2001
*/
/* /*
* Simple Wave Format Support * Simple Wave Format Support
* Copyright (c) 1999 by Jaroslav Kysela <perex@suse.cz> * Copyright (c) 1999 by Jaroslav Kysela <perex@suse.cz>
@ -28,6 +33,11 @@
#include <asm/byteorder.h> #include <asm/byteorder.h>
#include <sound/ainstr_simple.h> #include <sound/ainstr_simple.h>
/**
* \brief Free simple instrument
* \param simple Simple instrument handle
* \return 0 on success otherwise a negative error code
*/
int snd_instr_simple_free(snd_instr_simple_t *simple) int snd_instr_simple_free(snd_instr_simple_t *simple)
{ {
if (simple == NULL) if (simple == NULL)
@ -48,6 +58,14 @@ static long simple_size(simple_instrument_t *instr)
return size; return size;
} }
/**
* \brief Convert the simple instrument to byte stream
* \param simple Simple instrument handle
* \param name Simple instrument name
* \param __data Result - allocated byte stream
* \param __size Result - size of allocated byte stream
* \return 0 on success otherwise a negative error code
*/
int snd_instr_simple_convert_to_stream(snd_instr_simple_t *simple, int snd_instr_simple_convert_to_stream(snd_instr_simple_t *simple,
const char *name, const char *name,
snd_instr_header_t **__data, snd_instr_header_t **__data,
@ -97,6 +115,13 @@ int snd_instr_simple_convert_to_stream(snd_instr_simple_t *simple,
return 0; return 0;
} }
/**
* \brief Convert the byte stream to simple instrument
* \param __data byte stream
* \param size size of byte stream
* \param simple Result - simple instrument handle
* \return 0 on success otherwise a negative error code
*/
int snd_instr_simple_convert_from_stream(snd_instr_header_t *__data ATTRIBUTE_UNUSED, int snd_instr_simple_convert_from_stream(snd_instr_header_t *__data ATTRIBUTE_UNUSED,
size_t size ATTRIBUTE_UNUSED, size_t size ATTRIBUTE_UNUSED,
snd_instr_simple_t **simple ATTRIBUTE_UNUSED) snd_instr_simple_t **simple ATTRIBUTE_UNUSED)

4
src/mixer/simple.c
View file

@ -1131,7 +1131,7 @@ static int _snd_mixer_selem_set_switch_all(snd_mixer_elem_t *elem, int dir, int
*/ */
const char *snd_mixer_selem_channel_name(snd_mixer_selem_channel_id_t channel) const char *snd_mixer_selem_channel_name(snd_mixer_selem_channel_id_t channel)
{ {
static const char *array[snd_enum_to_int(SND_MIXER_SCHN_LAST) + 1] = { static const char *array[SND_MIXER_SCHN_LAST + 1] = {
[SND_MIXER_SCHN_FRONT_LEFT] = "Front Left", [SND_MIXER_SCHN_FRONT_LEFT] = "Front Left",
[SND_MIXER_SCHN_FRONT_RIGHT] = "Front Right", [SND_MIXER_SCHN_FRONT_RIGHT] = "Front Right",
[SND_MIXER_SCHN_FRONT_CENTER] = "Front Center", [SND_MIXER_SCHN_FRONT_CENTER] = "Front Center",
@ -1141,7 +1141,7 @@ const char *snd_mixer_selem_channel_name(snd_mixer_selem_channel_id_t channel)
}; };
const char *p; const char *p;
assert(channel <= SND_MIXER_SCHN_LAST); assert(channel <= SND_MIXER_SCHN_LAST);
p = array[snd_enum_to_int(channel)]; p = array[channel];
if (!p) if (!p)
return "?"; return "?";
return p; return p;

70
src/pcm/pcm.c
View file

@ -636,7 +636,7 @@ static const char *snd_pcm_tstamp_mode_names[] = {
const char *snd_pcm_stream_name(snd_pcm_stream_t stream) const char *snd_pcm_stream_name(snd_pcm_stream_t stream)
{ {
assert(stream <= SND_PCM_STREAM_LAST); assert(stream <= SND_PCM_STREAM_LAST);
return snd_pcm_stream_names[snd_enum_to_int(stream)]; return snd_pcm_stream_names[stream];
} }
/** /**
@ -647,7 +647,7 @@ const char *snd_pcm_stream_name(snd_pcm_stream_t stream)
const char *snd_pcm_access_name(snd_pcm_access_t acc) const char *snd_pcm_access_name(snd_pcm_access_t acc)
{ {
assert(acc <= SND_PCM_ACCESS_LAST); assert(acc <= SND_PCM_ACCESS_LAST);
return snd_pcm_access_names[snd_enum_to_int(acc)]; return snd_pcm_access_names[acc];
} }
/** /**
@ -658,7 +658,7 @@ const char *snd_pcm_access_name(snd_pcm_access_t acc)
const char *snd_pcm_format_name(snd_pcm_format_t format) const char *snd_pcm_format_name(snd_pcm_format_t format)
{ {
assert(format <= SND_PCM_FORMAT_LAST); assert(format <= SND_PCM_FORMAT_LAST);
return snd_pcm_format_names[snd_enum_to_int(format)]; return snd_pcm_format_names[format];
} }
/** /**
@ -669,7 +669,7 @@ const char *snd_pcm_format_name(snd_pcm_format_t format)
const char *snd_pcm_format_description(snd_pcm_format_t format) const char *snd_pcm_format_description(snd_pcm_format_t format)
{ {
assert(format <= SND_PCM_FORMAT_LAST); assert(format <= SND_PCM_FORMAT_LAST);
return snd_pcm_format_descriptions[snd_enum_to_int(format)]; return snd_pcm_format_descriptions[format];
} }
/** /**
@ -680,9 +680,9 @@ const char *snd_pcm_format_description(snd_pcm_format_t format)
snd_pcm_format_t snd_pcm_format_value(const char* name) snd_pcm_format_t snd_pcm_format_value(const char* name)
{ {
snd_pcm_format_t format; snd_pcm_format_t format;
for (format = 0; format <= SND_PCM_FORMAT_LAST; snd_enum_incr(format)) { for (format = 0; format <= SND_PCM_FORMAT_LAST; format++) {
if (snd_pcm_format_names[snd_enum_to_int(format)] && if (snd_pcm_format_names[format] &&
strcasecmp(name, snd_pcm_format_names[snd_enum_to_int(format)]) == 0) { strcasecmp(name, snd_pcm_format_names[format]) == 0) {
return format; return format;
} }
} }
@ -697,7 +697,7 @@ snd_pcm_format_t snd_pcm_format_value(const char* name)
const char *snd_pcm_subformat_name(snd_pcm_subformat_t subformat) const char *snd_pcm_subformat_name(snd_pcm_subformat_t subformat)
{ {
assert(subformat <= SND_PCM_SUBFORMAT_LAST); assert(subformat <= SND_PCM_SUBFORMAT_LAST);
return snd_pcm_subformat_names[snd_enum_to_int(subformat)]; return snd_pcm_subformat_names[subformat];
} }
/** /**
@ -708,7 +708,7 @@ const char *snd_pcm_subformat_name(snd_pcm_subformat_t subformat)
const char *snd_pcm_subformat_description(snd_pcm_subformat_t subformat) const char *snd_pcm_subformat_description(snd_pcm_subformat_t subformat)
{ {
assert(subformat <= SND_PCM_SUBFORMAT_LAST); assert(subformat <= SND_PCM_SUBFORMAT_LAST);
return snd_pcm_subformat_descriptions[snd_enum_to_int(subformat)]; return snd_pcm_subformat_descriptions[subformat];
} }
/** /**
@ -719,10 +719,12 @@ const char *snd_pcm_subformat_description(snd_pcm_subformat_t subformat)
const char *snd_pcm_start_mode_name(snd_pcm_start_t mode) const char *snd_pcm_start_mode_name(snd_pcm_start_t mode)
{ {
assert(mode <= SND_PCM_START_LAST); assert(mode <= SND_PCM_START_LAST);
return snd_pcm_start_mode_names[snd_enum_to_int(mode)]; return snd_pcm_start_mode_names[mode];
} }
#ifndef DOC_HIDDEN
link_warning(snd_pcm_start_mode_name, "Warning: start_mode is deprecated, consider to use start_threshold"); link_warning(snd_pcm_start_mode_name, "Warning: start_mode is deprecated, consider to use start_threshold");
#endif
/** /**
* \brief (DEPRECATED) get name of PCM xrun mode setting * \brief (DEPRECATED) get name of PCM xrun mode setting
@ -732,10 +734,12 @@ link_warning(snd_pcm_start_mode_name, "Warning: start_mode is deprecated, consid
const char *snd_pcm_xrun_mode_name(snd_pcm_xrun_t mode) const char *snd_pcm_xrun_mode_name(snd_pcm_xrun_t mode)
{ {
assert(mode <= SND_PCM_XRUN_LAST); assert(mode <= SND_PCM_XRUN_LAST);
return snd_pcm_xrun_mode_names[snd_enum_to_int(mode)]; return snd_pcm_xrun_mode_names[mode];
} }
#ifndef DOC_HIDDEN
link_warning(snd_pcm_xrun_mode_name, "Warning: xrun_mode is deprecated, consider to use stop_threshold"); link_warning(snd_pcm_xrun_mode_name, "Warning: xrun_mode is deprecated, consider to use stop_threshold");
#endif
/** /**
* \brief get name of PCM tstamp mode setting * \brief get name of PCM tstamp mode setting
@ -745,7 +749,7 @@ link_warning(snd_pcm_xrun_mode_name, "Warning: xrun_mode is deprecated, consider
const char *snd_pcm_tstamp_mode_name(snd_pcm_tstamp_t mode) const char *snd_pcm_tstamp_mode_name(snd_pcm_tstamp_t mode)
{ {
assert(mode <= SND_PCM_TSTAMP_LAST); assert(mode <= SND_PCM_TSTAMP_LAST);
return snd_pcm_tstamp_mode_names[snd_enum_to_int(mode)]; return snd_pcm_tstamp_mode_names[mode];
} }
/** /**
@ -756,7 +760,7 @@ const char *snd_pcm_tstamp_mode_name(snd_pcm_tstamp_t mode)
const char *snd_pcm_state_name(snd_pcm_state_t state) const char *snd_pcm_state_name(snd_pcm_state_t state)
{ {
assert(state <= SND_PCM_STATE_LAST); assert(state <= SND_PCM_STATE_LAST);
return snd_pcm_state_names[snd_enum_to_int(state)]; return snd_pcm_state_names[state];
} }
/** /**
@ -1867,7 +1871,7 @@ int snd_pcm_hw_params_get_access(const snd_pcm_hw_params_t *params)
*/ */
int snd_pcm_hw_params_test_access(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_access_t val) int snd_pcm_hw_params_test_access(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_access_t val)
{ {
return snd_pcm_hw_param_set(pcm, params, SND_TEST, SND_PCM_HW_PARAM_ACCESS, snd_enum_to_int(val), 0); return snd_pcm_hw_param_set(pcm, params, SND_TEST, SND_PCM_HW_PARAM_ACCESS, val, 0);
} }
/** /**
@ -1879,7 +1883,7 @@ int snd_pcm_hw_params_test_access(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, s
*/ */
int snd_pcm_hw_params_set_access(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_access_t val) int snd_pcm_hw_params_set_access(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_access_t val)
{ {
return snd_pcm_hw_param_set(pcm, params, SND_TRY, SND_PCM_HW_PARAM_ACCESS, snd_enum_to_int(val), 0); return snd_pcm_hw_param_set(pcm, params, SND_TRY, SND_PCM_HW_PARAM_ACCESS, val, 0);
} }
/** /**
@ -1890,7 +1894,7 @@ int snd_pcm_hw_params_set_access(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, sn
*/ */
snd_pcm_access_t snd_pcm_hw_params_set_access_first(snd_pcm_t *pcm, snd_pcm_hw_params_t *params) snd_pcm_access_t snd_pcm_hw_params_set_access_first(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
{ {
return snd_int_to_enum(snd_pcm_hw_param_set_first(pcm, params, SND_PCM_HW_PARAM_ACCESS, NULL)); return snd_pcm_hw_param_set_first(pcm, params, SND_PCM_HW_PARAM_ACCESS, NULL);
} }
/** /**
@ -1901,7 +1905,7 @@ snd_pcm_access_t snd_pcm_hw_params_set_access_first(snd_pcm_t *pcm, snd_pcm_hw_p
*/ */
snd_pcm_access_t snd_pcm_hw_params_set_access_last(snd_pcm_t *pcm, snd_pcm_hw_params_t *params) snd_pcm_access_t snd_pcm_hw_params_set_access_last(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
{ {
return snd_int_to_enum(snd_pcm_hw_param_set_last(pcm, params, SND_PCM_HW_PARAM_ACCESS, NULL)); return snd_pcm_hw_param_set_last(pcm, params, SND_PCM_HW_PARAM_ACCESS, NULL);
} }
/** /**
@ -1969,7 +1973,7 @@ int snd_pcm_hw_params_set_format(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, sn
*/ */
snd_pcm_format_t snd_pcm_hw_params_set_format_first(snd_pcm_t *pcm, snd_pcm_hw_params_t *params) snd_pcm_format_t snd_pcm_hw_params_set_format_first(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
{ {
return snd_int_to_enum(snd_pcm_hw_param_set_first(pcm, params, SND_PCM_HW_PARAM_FORMAT, NULL)); return snd_pcm_hw_param_set_first(pcm, params, SND_PCM_HW_PARAM_FORMAT, NULL);
} }
/** /**
@ -1980,7 +1984,7 @@ snd_pcm_format_t snd_pcm_hw_params_set_format_first(snd_pcm_t *pcm, snd_pcm_hw_p
*/ */
snd_pcm_format_t snd_pcm_hw_params_set_format_last(snd_pcm_t *pcm, snd_pcm_hw_params_t *params) snd_pcm_format_t snd_pcm_hw_params_set_format_last(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
{ {
return snd_int_to_enum(snd_pcm_hw_param_set_last(pcm, params, SND_PCM_HW_PARAM_FORMAT, NULL)); return snd_pcm_hw_param_set_last(pcm, params, SND_PCM_HW_PARAM_FORMAT, NULL);
} }
/** /**
@ -2015,7 +2019,7 @@ void snd_pcm_hw_params_get_format_mask(snd_pcm_hw_params_t *params, snd_pcm_form
*/ */
int snd_pcm_hw_params_test_subformat(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_subformat_t val) int snd_pcm_hw_params_test_subformat(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_subformat_t val)
{ {
return snd_pcm_hw_param_set(pcm, params, SND_TEST, SND_PCM_HW_PARAM_SUBFORMAT, snd_enum_to_int(val), 0); return snd_pcm_hw_param_set(pcm, params, SND_TEST, SND_PCM_HW_PARAM_SUBFORMAT, val, 0);
} }
/** /**
@ -2037,7 +2041,7 @@ int snd_pcm_hw_params_get_subformat(const snd_pcm_hw_params_t *params)
*/ */
int snd_pcm_hw_params_set_subformat(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_subformat_t val) int snd_pcm_hw_params_set_subformat(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_subformat_t val)
{ {
return snd_pcm_hw_param_set(pcm, params, SND_TRY, SND_PCM_HW_PARAM_SUBFORMAT, snd_enum_to_int(val), 0); return snd_pcm_hw_param_set(pcm, params, SND_TRY, SND_PCM_HW_PARAM_SUBFORMAT, val, 0);
} }
/** /**
@ -2048,7 +2052,7 @@ int snd_pcm_hw_params_set_subformat(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
*/ */
snd_pcm_subformat_t snd_pcm_hw_params_set_subformat_first(snd_pcm_t *pcm, snd_pcm_hw_params_t *params) snd_pcm_subformat_t snd_pcm_hw_params_set_subformat_first(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
{ {
return snd_int_to_enum(snd_pcm_hw_param_set_first(pcm, params, SND_PCM_HW_PARAM_SUBFORMAT, NULL)); return snd_pcm_hw_param_set_first(pcm, params, SND_PCM_HW_PARAM_SUBFORMAT, NULL);
} }
/** /**
@ -2059,7 +2063,7 @@ snd_pcm_subformat_t snd_pcm_hw_params_set_subformat_first(snd_pcm_t *pcm, snd_pc
*/ */
snd_pcm_subformat_t snd_pcm_hw_params_set_subformat_last(snd_pcm_t *pcm, snd_pcm_hw_params_t *params) snd_pcm_subformat_t snd_pcm_hw_params_set_subformat_last(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
{ {
return snd_int_to_enum(snd_pcm_hw_param_set_last(pcm, params, SND_PCM_HW_PARAM_SUBFORMAT, NULL)); return snd_pcm_hw_param_set_last(pcm, params, SND_PCM_HW_PARAM_SUBFORMAT, NULL);
} }
/** /**
@ -3368,7 +3372,7 @@ int snd_pcm_sw_params_current(snd_pcm_t *pcm, snd_pcm_sw_params_t *params)
{ {
assert(pcm && params); assert(pcm && params);
assert(pcm->setup); assert(pcm->setup);
params->tstamp_mode = snd_enum_to_int(pcm->tstamp_mode); params->tstamp_mode = pcm->tstamp_mode;
params->period_step = pcm->period_step; params->period_step = pcm->period_step;
params->sleep_min = pcm->sleep_min; params->sleep_min = pcm->sleep_min;
params->avail_min = pcm->avail_min; params->avail_min = pcm->avail_min;
@ -3537,7 +3541,7 @@ int snd_pcm_sw_params_set_tstamp_mode(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_s
{ {
assert(pcm && params); assert(pcm && params);
assert(val <= SND_PCM_TSTAMP_LAST); assert(val <= SND_PCM_TSTAMP_LAST);
params->tstamp_mode = snd_enum_to_int(val); params->tstamp_mode = val;
return 0; return 0;
} }
@ -3549,7 +3553,7 @@ int snd_pcm_sw_params_set_tstamp_mode(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_s
snd_pcm_tstamp_t snd_pcm_sw_params_get_tstamp_mode(const snd_pcm_sw_params_t *params) snd_pcm_tstamp_t snd_pcm_sw_params_get_tstamp_mode(const snd_pcm_sw_params_t *params)
{ {
assert(params); assert(params);
return snd_int_to_enum(params->tstamp_mode); return params->tstamp_mode;
} }
@ -3829,7 +3833,7 @@ void snd_pcm_status_copy(snd_pcm_status_t *dst, const snd_pcm_status_t *src)
snd_pcm_state_t snd_pcm_status_get_state(const snd_pcm_status_t *obj) snd_pcm_state_t snd_pcm_status_get_state(const snd_pcm_status_t *obj)
{ {
assert(obj); assert(obj);
return snd_int_to_enum(obj->state); return obj->state;
} }
/** /**
@ -3961,7 +3965,7 @@ unsigned int snd_pcm_info_get_subdevice(const snd_pcm_info_t *obj)
snd_pcm_stream_t snd_pcm_info_get_stream(const snd_pcm_info_t *obj) snd_pcm_stream_t snd_pcm_info_get_stream(const snd_pcm_info_t *obj)
{ {
assert(obj); assert(obj);
return snd_int_to_enum(obj->stream); return obj->stream;
} }
/** /**
@ -4016,7 +4020,7 @@ const char *snd_pcm_info_get_subdevice_name(const snd_pcm_info_t *obj)
snd_pcm_class_t snd_pcm_info_get_class(const snd_pcm_info_t *obj) snd_pcm_class_t snd_pcm_info_get_class(const snd_pcm_info_t *obj)
{ {
assert(obj); assert(obj);
return snd_int_to_enum(obj->dev_class); return obj->dev_class;
} }
/** /**
@ -4027,7 +4031,7 @@ snd_pcm_class_t snd_pcm_info_get_class(const snd_pcm_info_t *obj)
snd_pcm_subclass_t snd_pcm_info_get_subclass(const snd_pcm_info_t *obj) snd_pcm_subclass_t snd_pcm_info_get_subclass(const snd_pcm_info_t *obj)
{ {
assert(obj); assert(obj);
return snd_int_to_enum(obj->dev_subclass); return obj->dev_subclass;
} }
/** /**
@ -4082,7 +4086,7 @@ void snd_pcm_info_set_subdevice(snd_pcm_info_t *obj, unsigned int val)
void snd_pcm_info_set_stream(snd_pcm_info_t *obj, snd_pcm_stream_t val) void snd_pcm_info_set_stream(snd_pcm_info_t *obj, snd_pcm_stream_t val)
{ {
assert(obj); assert(obj);
obj->stream = snd_enum_to_int(val); obj->stream = val;
} }
/** /**
@ -4183,7 +4187,7 @@ snd_pcm_sframes_t snd_pcm_read_areas(snd_pcm_t *pcm, const snd_pcm_channel_area_
if (size > pcm->xfer_align) if (size > pcm->xfer_align)
size -= size % pcm->xfer_align; size -= size % pcm->xfer_align;
switch (snd_enum_to_int(state)) { switch (state) {
case SND_PCM_STATE_PREPARED: case SND_PCM_STATE_PREPARED:
if (size >= pcm->start_threshold) { if (size >= pcm->start_threshold) {
err = snd_pcm_start(pcm); err = snd_pcm_start(pcm);
@ -4267,7 +4271,7 @@ snd_pcm_sframes_t snd_pcm_write_areas(snd_pcm_t *pcm, const snd_pcm_channel_area
if (size > pcm->xfer_align) if (size > pcm->xfer_align)
size -= size % pcm->xfer_align; size -= size % pcm->xfer_align;
switch (snd_enum_to_int(state)) { switch (state) {
case SND_PCM_STATE_PREPARED: case SND_PCM_STATE_PREPARED:
case SND_PCM_STATE_RUNNING: case SND_PCM_STATE_RUNNING:
break; break;

2
src/pcm/pcm_hw.c
View file

@ -545,7 +545,7 @@ int snd_pcm_hw_open(snd_pcm_t **pcmp, const char *name, int card, int device, in
if ((ret = snd_ctl_hw_open(&ctl, NULL, card, 0)) < 0) if ((ret = snd_ctl_hw_open(&ctl, NULL, card, 0)) < 0)
return ret; return ret;
switch (snd_enum_to_int(stream)) { switch (stream) {
case SND_PCM_STREAM_PLAYBACK: case SND_PCM_STREAM_PLAYBACK:
filefmt = SNDRV_FILE_PCM_STREAM_PLAYBACK; filefmt = SNDRV_FILE_PCM_STREAM_PLAYBACK;
break; break;

14
src/pcm/pcm_misc.c
View file

@ -34,7 +34,7 @@
*/ */
int snd_pcm_format_signed(snd_pcm_format_t format) int snd_pcm_format_signed(snd_pcm_format_t format)
{ {
switch (snd_enum_to_int(format)) { switch (format) {
case SNDRV_PCM_FORMAT_S8: case SNDRV_PCM_FORMAT_S8:
case SNDRV_PCM_FORMAT_S16_LE: case SNDRV_PCM_FORMAT_S16_LE:
case SNDRV_PCM_FORMAT_S16_BE: case SNDRV_PCM_FORMAT_S16_BE:
@ -88,7 +88,7 @@ int snd_pcm_format_linear(snd_pcm_format_t format)
*/ */
int snd_pcm_format_little_endian(snd_pcm_format_t format) int snd_pcm_format_little_endian(snd_pcm_format_t format)
{ {
switch (snd_enum_to_int(format)) { switch (format) {
case SNDRV_PCM_FORMAT_S16_LE: case SNDRV_PCM_FORMAT_S16_LE:
case SNDRV_PCM_FORMAT_U16_LE: case SNDRV_PCM_FORMAT_U16_LE:
case SNDRV_PCM_FORMAT_S24_LE: case SNDRV_PCM_FORMAT_S24_LE:
@ -150,7 +150,7 @@ int snd_pcm_format_cpu_endian(snd_pcm_format_t format)
*/ */
int snd_pcm_format_width(snd_pcm_format_t format) int snd_pcm_format_width(snd_pcm_format_t format)
{ {
switch (snd_enum_to_int(format)) { switch (format) {
case SNDRV_PCM_FORMAT_S8: case SNDRV_PCM_FORMAT_S8:
case SNDRV_PCM_FORMAT_U8: case SNDRV_PCM_FORMAT_U8:
return 8; return 8;
@ -194,7 +194,7 @@ int snd_pcm_format_width(snd_pcm_format_t format)
*/ */
int snd_pcm_format_physical_width(snd_pcm_format_t format) int snd_pcm_format_physical_width(snd_pcm_format_t format)
{ {
switch (snd_enum_to_int(format)) { switch (format) {
case SNDRV_PCM_FORMAT_S8: case SNDRV_PCM_FORMAT_S8:
case SNDRV_PCM_FORMAT_U8: case SNDRV_PCM_FORMAT_U8:
return 8; return 8;
@ -237,7 +237,7 @@ int snd_pcm_format_physical_width(snd_pcm_format_t format)
*/ */
ssize_t snd_pcm_format_size(snd_pcm_format_t format, size_t samples) ssize_t snd_pcm_format_size(snd_pcm_format_t format, size_t samples)
{ {
switch (snd_enum_to_int(format)) { switch (format) {
case SNDRV_PCM_FORMAT_S8: case SNDRV_PCM_FORMAT_S8:
case SNDRV_PCM_FORMAT_U8: case SNDRV_PCM_FORMAT_U8:
return samples; return samples;
@ -283,7 +283,7 @@ ssize_t snd_pcm_format_size(snd_pcm_format_t format, size_t samples)
*/ */
u_int64_t snd_pcm_format_silence_64(snd_pcm_format_t format) u_int64_t snd_pcm_format_silence_64(snd_pcm_format_t format)
{ {
switch (snd_enum_to_int(format)) { switch (format) {
case SNDRV_PCM_FORMAT_S8: case SNDRV_PCM_FORMAT_S8:
case SNDRV_PCM_FORMAT_S16_LE: case SNDRV_PCM_FORMAT_S16_LE:
case SNDRV_PCM_FORMAT_S16_BE: case SNDRV_PCM_FORMAT_S16_BE:
@ -518,5 +518,5 @@ snd_pcm_format_t snd_pcm_build_linear_format(int width, int unsignd, int big_end
default: default:
return SND_PCM_FORMAT_UNKNOWN; return SND_PCM_FORMAT_UNKNOWN;
} }
return snd_int_to_enum(((int(*)[2][2])linear_formats)[width][!!unsignd][!!big_endian]); return ((int(*)[2][2])linear_formats)[width][!!unsignd][!!big_endian];
} }

6
src/pcm/pcm_mmap.c
View file

@ -166,7 +166,7 @@ int snd_pcm_channel_info(snd_pcm_t *pcm, snd_pcm_channel_info_t *info)
int snd_pcm_channel_info_shm(snd_pcm_t *pcm, snd_pcm_channel_info_t *info, int snd_pcm_channel_info_shm(snd_pcm_t *pcm, snd_pcm_channel_info_t *info,
int shmid) int shmid)
{ {
switch (snd_enum_to_int(pcm->access)) { switch (pcm->access) {
case SND_PCM_ACCESS_MMAP_INTERLEAVED: case SND_PCM_ACCESS_MMAP_INTERLEAVED:
case SND_PCM_ACCESS_RW_INTERLEAVED: case SND_PCM_ACCESS_RW_INTERLEAVED:
info->first = info->channel * pcm->sample_bits; info->first = info->channel * pcm->sample_bits;
@ -367,7 +367,7 @@ snd_pcm_sframes_t snd_pcm_write_mmap(snd_pcm_t *pcm, snd_pcm_uframes_t size)
snd_pcm_uframes_t cont = pcm->buffer_size - offset; snd_pcm_uframes_t cont = pcm->buffer_size - offset;
if (cont < frames) if (cont < frames)
frames = cont; frames = cont;
switch (snd_enum_to_int(pcm->access)) { switch (pcm->access) {
case SND_PCM_ACCESS_MMAP_INTERLEAVED: case SND_PCM_ACCESS_MMAP_INTERLEAVED:
{ {
const snd_pcm_channel_area_t *a = snd_pcm_mmap_areas(pcm); const snd_pcm_channel_area_t *a = snd_pcm_mmap_areas(pcm);
@ -413,7 +413,7 @@ snd_pcm_sframes_t snd_pcm_read_mmap(snd_pcm_t *pcm, snd_pcm_uframes_t size)
snd_pcm_uframes_t cont = pcm->buffer_size - offset; snd_pcm_uframes_t cont = pcm->buffer_size - offset;
if (cont < frames) if (cont < frames)
frames = cont; frames = cont;
switch (snd_enum_to_int(pcm->access)) { switch (pcm->access) {
case SND_PCM_ACCESS_MMAP_INTERLEAVED: case SND_PCM_ACCESS_MMAP_INTERLEAVED:
{ {
const snd_pcm_channel_area_t *a = snd_pcm_mmap_areas(pcm); const snd_pcm_channel_area_t *a = snd_pcm_mmap_areas(pcm);

8
src/pcm/pcm_null.c
View file

@ -55,7 +55,7 @@ static int snd_pcm_null_async(snd_pcm_t *pcm ATTRIBUTE_UNUSED, int sig ATTRIBUTE
static int snd_pcm_null_info(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_info_t * info) static int snd_pcm_null_info(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_info_t * info)
{ {
memset(info, 0, sizeof(*info)); memset(info, 0, sizeof(*info));
info->stream = snd_enum_to_int(pcm->stream); info->stream = pcm->stream;
info->card = -1; info->card = -1;
strncpy(info->id, pcm->name, sizeof(info->id)); strncpy(info->id, pcm->name, sizeof(info->id));
strncpy(info->name, pcm->name, sizeof(info->name)); strncpy(info->name, pcm->name, sizeof(info->name));
@ -74,7 +74,7 @@ static int snd_pcm_null_status(snd_pcm_t *pcm, snd_pcm_status_t * status)
{ {
snd_pcm_null_t *null = pcm->private_data; snd_pcm_null_t *null = pcm->private_data;
memset(status, 0, sizeof(*status)); memset(status, 0, sizeof(*status));
status->state = snd_enum_to_int(null->state); status->state = null->state;
status->trigger_tstamp = null->trigger_tstamp; status->trigger_tstamp = null->trigger_tstamp;
gettimeofday(&status->tstamp, 0); gettimeofday(&status->tstamp, 0);
status->avail = pcm->buffer_size; status->avail = pcm->buffer_size;
@ -154,7 +154,7 @@ static int snd_pcm_null_pause(snd_pcm_t *pcm, int enable)
static snd_pcm_sframes_t snd_pcm_null_rewind(snd_pcm_t *pcm, snd_pcm_uframes_t frames) static snd_pcm_sframes_t snd_pcm_null_rewind(snd_pcm_t *pcm, snd_pcm_uframes_t frames)
{ {
snd_pcm_null_t *null = pcm->private_data; snd_pcm_null_t *null = pcm->private_data;
switch (snd_enum_to_int(null->state)) { switch (null->state) {
case SND_PCM_STATE_RUNNING: case SND_PCM_STATE_RUNNING:
snd_pcm_mmap_hw_backward(pcm, frames); snd_pcm_mmap_hw_backward(pcm, frames);
/* Fall through */ /* Fall through */
@ -169,7 +169,7 @@ static snd_pcm_sframes_t snd_pcm_null_rewind(snd_pcm_t *pcm, snd_pcm_uframes_t f
static snd_pcm_sframes_t snd_pcm_null_fwd(snd_pcm_t *pcm, snd_pcm_uframes_t size) static snd_pcm_sframes_t snd_pcm_null_fwd(snd_pcm_t *pcm, snd_pcm_uframes_t size)
{ {
snd_pcm_null_t *null = pcm->private_data; snd_pcm_null_t *null = pcm->private_data;
switch (snd_enum_to_int(null->state)) { switch (null->state) {
case SND_PCM_STATE_RUNNING: case SND_PCM_STATE_RUNNING:
snd_pcm_mmap_hw_forward(pcm, size); snd_pcm_mmap_hw_forward(pcm, size);
/* Fall through */ /* Fall through */

26
src/pcm/pcm_params.c
View file

@ -232,7 +232,7 @@ int snd_pcm_hw_param_set_integer(snd_pcm_t *pcm,
{ {
snd_pcm_hw_params_t save; snd_pcm_hw_params_t save;
int err; int err;
switch (snd_enum_to_int(mode)) { switch (mode) {
case SND_CHANGE: case SND_CHANGE:
break; break;
case SND_TRY: case SND_TRY:
@ -373,7 +373,7 @@ int snd_pcm_hw_param_set_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
{ {
snd_pcm_hw_params_t save; snd_pcm_hw_params_t save;
int err; int err;
switch (snd_enum_to_int(mode)) { switch (mode) {
case SND_CHANGE: case SND_CHANGE:
break; break;
case SND_TRY: case SND_TRY:
@ -445,7 +445,7 @@ int snd_pcm_hw_param_set_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
{ {
snd_pcm_hw_params_t save; snd_pcm_hw_params_t save;
int err; int err;
switch (snd_enum_to_int(mode)) { switch (mode) {
case SND_CHANGE: case SND_CHANGE:
break; break;
case SND_TRY: case SND_TRY:
@ -553,7 +553,7 @@ int snd_pcm_hw_param_set_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
{ {
snd_pcm_hw_params_t save; snd_pcm_hw_params_t save;
int err; int err;
switch (snd_enum_to_int(mode)) { switch (mode) {
case SND_CHANGE: case SND_CHANGE:
break; break;
case SND_TRY: case SND_TRY:
@ -645,7 +645,7 @@ int snd_pcm_hw_param_set(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
{ {
snd_pcm_hw_params_t save; snd_pcm_hw_params_t save;
int err; int err;
switch (snd_enum_to_int(mode)) { switch (mode) {
case SND_CHANGE: case SND_CHANGE:
break; break;
case SND_TRY: case SND_TRY:
@ -700,7 +700,7 @@ int snd_pcm_hw_param_set_mask(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
{ {
snd_pcm_hw_params_t save; snd_pcm_hw_params_t save;
int err; int err;
switch (snd_enum_to_int(mode)) { switch (mode) {
case SND_CHANGE: case SND_CHANGE:
break; break;
case SND_TRY: case SND_TRY:
@ -1049,13 +1049,13 @@ void snd_pcm_hw_param_dump(const snd_pcm_hw_params_t *params,
const char *s; const char *s;
switch (var) { switch (var) {
case SND_PCM_HW_PARAM_ACCESS: case SND_PCM_HW_PARAM_ACCESS:
s = snd_pcm_access_name(snd_int_to_enum(k)); s = snd_pcm_access_name(k);
break; break;
case SND_PCM_HW_PARAM_FORMAT: case SND_PCM_HW_PARAM_FORMAT:
s = snd_pcm_format_name(snd_int_to_enum(k)); s = snd_pcm_format_name(k);
break; break;
case SND_PCM_HW_PARAM_SUBFORMAT: case SND_PCM_HW_PARAM_SUBFORMAT:
s = snd_pcm_subformat_name(snd_int_to_enum(k)); s = snd_pcm_subformat_name(k);
break; break;
default: default:
assert(0); assert(0);
@ -1100,7 +1100,7 @@ const char *snd_pcm_hw_param_names[] = {
const char *snd_pcm_hw_param_name(snd_pcm_hw_param_t param) const char *snd_pcm_hw_param_name(snd_pcm_hw_param_t param)
{ {
assert(param <= SND_PCM_HW_PARAM_LAST); assert(param <= SND_PCM_HW_PARAM_LAST);
return snd_pcm_hw_param_names[snd_enum_to_int(param)]; return snd_pcm_hw_param_names[param];
} }
#if 0 #if 0
@ -1561,7 +1561,7 @@ static int snd_pcm_hw_rule_format(snd_pcm_hw_params_t *params,
snd_pcm_format_t k; snd_pcm_format_t k;
snd_mask_t *mask = hw_param_mask(params, rule->var); snd_mask_t *mask = hw_param_mask(params, rule->var);
snd_interval_t *i = hw_param_interval(params, rule->deps[0]); snd_interval_t *i = hw_param_interval(params, rule->deps[0]);
for (k = 0; k <= SND_PCM_FORMAT_LAST; snd_enum_incr(k)) { for (k = 0; k <= SND_PCM_FORMAT_LAST; k++) {
int bits; int bits;
if (!snd_pcm_format_mask_test(mask, k)) if (!snd_pcm_format_mask_test(mask, k))
continue; continue;
@ -1589,7 +1589,7 @@ static int snd_pcm_hw_rule_sample_bits(snd_pcm_hw_params_t *params,
int c, changed = 0; int c, changed = 0;
min = UINT_MAX; min = UINT_MAX;
max = 0; max = 0;
for (k = 0; k <= SND_PCM_FORMAT_LAST; snd_enum_incr(k)) { for (k = 0; k <= SND_PCM_FORMAT_LAST; k++) {
int bits; int bits;
if (!snd_pcm_format_mask_test(mask, k)) if (!snd_pcm_format_mask_test(mask, k))
continue; continue;
@ -2022,7 +2022,7 @@ static int snd_pcm_sw_params_default(snd_pcm_t *pcm, snd_pcm_sw_params_t *params
{ {
assert(pcm && params); assert(pcm && params);
assert(pcm->setup); assert(pcm->setup);
params->tstamp_mode = snd_enum_to_int(SND_PCM_TSTAMP_NONE); params->tstamp_mode = SND_PCM_TSTAMP_NONE;
params->period_step = 1; params->period_step = 1;
params->sleep_min = 0; params->sleep_min = 0;
params->avail_min = pcm->period_size; params->avail_min = pcm->period_size;

16
src/pcm/pcm_plug.c
View file

@ -124,7 +124,7 @@ static snd_pcm_format_t snd_pcm_plug_slave_format(snd_pcm_format_t format, const
return format; return format;
if (!snd_pcm_format_mask_test(&lin, format)) { if (!snd_pcm_format_mask_test(&lin, format)) {
unsigned int i; unsigned int i;
switch (snd_enum_to_int(format)) { switch (format) {
case SND_PCM_FORMAT_MU_LAW: case SND_PCM_FORMAT_MU_LAW:
case SND_PCM_FORMAT_A_LAW: case SND_PCM_FORMAT_A_LAW:
case SND_PCM_FORMAT_IMA_ADPCM: case SND_PCM_FORMAT_IMA_ADPCM:
@ -179,9 +179,9 @@ static snd_pcm_format_t snd_pcm_plug_slave_format(snd_pcm_format_t format, const
} }
#define SND_PCM_FMTBIT_PLUG (SND_PCM_FMTBIT_LINEAR | \ #define SND_PCM_FMTBIT_PLUG (SND_PCM_FMTBIT_LINEAR | \
(1 << snd_enum_to_int(SND_PCM_FORMAT_MU_LAW)) | \ (1 << SND_PCM_FORMAT_MU_LAW) | \
(1 << snd_enum_to_int(SND_PCM_FORMAT_A_LAW)) | \ (1 << SND_PCM_FORMAT_A_LAW) | \
(1 << snd_enum_to_int(SND_PCM_FORMAT_IMA_ADPCM))) (1 << SND_PCM_FORMAT_IMA_ADPCM))
static void snd_pcm_plug_clear(snd_pcm_t *pcm) static void snd_pcm_plug_clear(snd_pcm_t *pcm)
@ -299,7 +299,7 @@ static int snd_pcm_plug_change_format(snd_pcm_t *pcm, snd_pcm_t **new, snd_pcm_p
clt->channels != slv->channels) clt->channels != slv->channels)
return 0; return 0;
cfmt = clt->format; cfmt = clt->format;
switch (snd_enum_to_int(clt->format)) { switch (clt->format) {
case SND_PCM_FORMAT_MU_LAW: case SND_PCM_FORMAT_MU_LAW:
f = snd_pcm_mulaw_open; f = snd_pcm_mulaw_open;
break; break;
@ -320,7 +320,7 @@ static int snd_pcm_plug_change_format(snd_pcm_t *pcm, snd_pcm_t **new, snd_pcm_p
clt->rate == slv->rate && clt->rate == slv->rate &&
clt->channels == clt->channels) clt->channels == clt->channels)
return 0; return 0;
switch (snd_enum_to_int(slv->format)) { switch (slv->format) {
case SND_PCM_FORMAT_MU_LAW: case SND_PCM_FORMAT_MU_LAW:
f = snd_pcm_mulaw_open; f = snd_pcm_mulaw_open;
break; break;
@ -455,7 +455,7 @@ static int snd_pcm_plug_hw_refine_schange(snd_pcm_t *pcm, snd_pcm_hw_params_t *p
sformat_mask = snd_pcm_hw_param_get_mask(sparams, sformat_mask = snd_pcm_hw_param_get_mask(sparams,
SND_PCM_HW_PARAM_FORMAT); SND_PCM_HW_PARAM_FORMAT);
snd_mask_none(&sfmt_mask); snd_mask_none(&sfmt_mask);
for (format = 0; format <= SND_PCM_FORMAT_LAST; snd_enum_incr(format)) { for (format = 0; format <= SND_PCM_FORMAT_LAST; format++) {
snd_pcm_format_t f; snd_pcm_format_t f;
if (!snd_pcm_format_mask_test(format_mask, format)) if (!snd_pcm_format_mask_test(format_mask, format))
continue; continue;
@ -530,7 +530,7 @@ static int snd_pcm_plug_hw_refine_cchange(snd_pcm_t *pcm ATTRIBUTE_UNUSED,
sformat_mask = snd_pcm_hw_param_get_mask(sparams, sformat_mask = snd_pcm_hw_param_get_mask(sparams,
SND_PCM_HW_PARAM_FORMAT); SND_PCM_HW_PARAM_FORMAT);
snd_mask_none(&fmt_mask); snd_mask_none(&fmt_mask);
for (format = 0; format <= SND_PCM_FORMAT_LAST; snd_enum_incr(format)) { for (format = 0; format <= SND_PCM_FORMAT_LAST; format++) {
snd_pcm_format_t f; snd_pcm_format_t f;
if (!snd_pcm_format_mask_test(format_mask, format)) if (!snd_pcm_format_mask_test(format_mask, format))
continue; continue;

20
src/pcm/pcm_share.c
View file

@ -136,7 +136,7 @@ static snd_pcm_uframes_t _snd_pcm_share_slave_forward(snd_pcm_share_slave_t *sla
list_for_each(i, &slave->clients) { list_for_each(i, &slave->clients) {
snd_pcm_share_t *share = list_entry(i, snd_pcm_share_t, list); snd_pcm_share_t *share = list_entry(i, snd_pcm_share_t, list);
snd_pcm_t *pcm = share->pcm; snd_pcm_t *pcm = share->pcm;
switch (snd_enum_to_int(share->state)) { switch (share->state) {
case SND_PCM_STATE_RUNNING: case SND_PCM_STATE_RUNNING:
break; break;
case SND_PCM_STATE_DRAINING: case SND_PCM_STATE_DRAINING:
@ -193,7 +193,7 @@ static snd_pcm_uframes_t _snd_pcm_share_missing(snd_pcm_t *pcm)
snd_pcm_uframes_t missing = INT_MAX; snd_pcm_uframes_t missing = INT_MAX;
snd_pcm_sframes_t ready_missing; snd_pcm_sframes_t ready_missing;
// printf("state=%d hw_ptr=%d appl_ptr=%d slave appl_ptr=%d safety=%d silence=%d\n", share->state, slave->hw_ptr, share->appl_ptr, *slave->pcm->appl_ptr, slave->safety_threshold, slave->silence_frames); // printf("state=%d hw_ptr=%d appl_ptr=%d slave appl_ptr=%d safety=%d silence=%d\n", share->state, slave->hw_ptr, share->appl_ptr, *slave->pcm->appl_ptr, slave->safety_threshold, slave->silence_frames);
switch (snd_enum_to_int(share->state)) { switch (share->state) {
case SND_PCM_STATE_RUNNING: case SND_PCM_STATE_RUNNING:
break; break;
case SND_PCM_STATE_DRAINING: case SND_PCM_STATE_DRAINING:
@ -232,7 +232,7 @@ static snd_pcm_uframes_t _snd_pcm_share_missing(snd_pcm_t *pcm)
missing = safety_missing; missing = safety_missing;
} }
} }
switch (snd_enum_to_int(share->state)) { switch (share->state) {
case SND_PCM_STATE_DRAINING: case SND_PCM_STATE_DRAINING:
if (pcm->stream == SND_PCM_STREAM_PLAYBACK) { if (pcm->stream == SND_PCM_STREAM_PLAYBACK) {
if (hw_avail <= 0) { if (hw_avail <= 0) {
@ -683,7 +683,7 @@ static int snd_pcm_share_status(snd_pcm_t *pcm, snd_pcm_status_t *status)
goto _end; goto _end;
_notrunning: _notrunning:
status->delay = sd + d; status->delay = sd + d;
status->state = snd_enum_to_int(share->state); status->state = share->state;
status->trigger_tstamp = share->trigger_tstamp; status->trigger_tstamp = share->trigger_tstamp;
_end: _end:
Pthread_mutex_unlock(&slave->mutex); Pthread_mutex_unlock(&slave->mutex);
@ -702,7 +702,7 @@ static int _snd_pcm_share_delay(snd_pcm_t *pcm, snd_pcm_sframes_t *delayp)
snd_pcm_share_slave_t *slave = share->slave; snd_pcm_share_slave_t *slave = share->slave;
int err = 0; int err = 0;
snd_pcm_sframes_t sd; snd_pcm_sframes_t sd;
switch (snd_enum_to_int(share->state)) { switch (share->state) {
case SND_PCM_STATE_XRUN: case SND_PCM_STATE_XRUN:
return -EPIPE; return -EPIPE;
case SND_PCM_STATE_RUNNING: case SND_PCM_STATE_RUNNING:
@ -919,7 +919,7 @@ static snd_pcm_sframes_t _snd_pcm_share_rewind(snd_pcm_t *pcm, snd_pcm_uframes_t
snd_pcm_share_t *share = pcm->private_data; snd_pcm_share_t *share = pcm->private_data;
snd_pcm_share_slave_t *slave = share->slave; snd_pcm_share_slave_t *slave = share->slave;
snd_pcm_sframes_t n; snd_pcm_sframes_t n;
switch (snd_enum_to_int(share->state)) { switch (share->state) {
case SND_PCM_STATE_RUNNING: case SND_PCM_STATE_RUNNING:
break; break;
case SND_PCM_STATE_PREPARED: case SND_PCM_STATE_PREPARED:
@ -1007,7 +1007,7 @@ static int snd_pcm_share_drain(snd_pcm_t *pcm)
snd_pcm_share_slave_t *slave = share->slave; snd_pcm_share_slave_t *slave = share->slave;
int err = 0; int err = 0;
Pthread_mutex_lock(&slave->mutex); Pthread_mutex_lock(&slave->mutex);
switch (snd_enum_to_int(share->state)) { switch (share->state) {
case SND_PCM_STATE_OPEN: case SND_PCM_STATE_OPEN:
err = -EBADFD; err = -EBADFD;
goto _end; goto _end;
@ -1020,7 +1020,7 @@ static int snd_pcm_share_drain(snd_pcm_t *pcm)
break; break;
} }
if (pcm->stream == SND_PCM_STREAM_PLAYBACK) { if (pcm->stream == SND_PCM_STREAM_PLAYBACK) {
switch (snd_enum_to_int(share->state)) { switch (share->state) {
case SND_PCM_STATE_XRUN: case SND_PCM_STATE_XRUN:
share->state = SND_PCM_STATE_SETUP; share->state = SND_PCM_STATE_SETUP;
goto _end; goto _end;
@ -1037,7 +1037,7 @@ static int snd_pcm_share_drain(snd_pcm_t *pcm)
break; break;
} }
} else { } else {
switch (snd_enum_to_int(share->state)) { switch (share->state) {
case SND_PCM_STATE_RUNNING: case SND_PCM_STATE_RUNNING:
_snd_pcm_share_stop(pcm, SND_PCM_STATE_DRAINING); _snd_pcm_share_stop(pcm, SND_PCM_STATE_DRAINING);
_snd_pcm_share_update(pcm); _snd_pcm_share_update(pcm);
@ -1065,7 +1065,7 @@ static int snd_pcm_share_drop(snd_pcm_t *pcm)
snd_pcm_share_slave_t *slave = share->slave; snd_pcm_share_slave_t *slave = share->slave;
int err = 0; int err = 0;
Pthread_mutex_lock(&slave->mutex); Pthread_mutex_lock(&slave->mutex);
switch (snd_enum_to_int(share->state)) { switch (share->state) {
case SND_PCM_STATE_OPEN: case SND_PCM_STATE_OPEN:
err = -EBADFD; err = -EBADFD;
goto _end; goto _end;

4
src/pcm/pcm_shm.c
View file

@ -341,7 +341,7 @@ static snd_pcm_state_t snd_pcm_shm_state(snd_pcm_t *pcm)
snd_pcm_shm_t *shm = pcm->private_data; snd_pcm_shm_t *shm = pcm->private_data;
volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl; volatile snd_pcm_shm_ctrl_t *ctrl = shm->ctrl;
ctrl->cmd = SND_PCM_IOCTL_STATE; ctrl->cmd = SND_PCM_IOCTL_STATE;
return snd_int_to_enum(snd_pcm_shm_action(pcm)); return snd_pcm_shm_action(pcm);
} }
static int snd_pcm_shm_delay(snd_pcm_t *pcm, snd_pcm_sframes_t *delayp) static int snd_pcm_shm_delay(snd_pcm_t *pcm, snd_pcm_sframes_t *delayp)
@ -591,7 +591,7 @@ int snd_pcm_shm_open(snd_pcm_t **pcmp, const char *name, const char *sockname, c
memcpy(req->name, sname, snamelen); memcpy(req->name, sname, snamelen);
req->dev_type = SND_DEV_TYPE_PCM; req->dev_type = SND_DEV_TYPE_PCM;
req->transport_type = SND_TRANSPORT_TYPE_SHM; req->transport_type = SND_TRANSPORT_TYPE_SHM;
req->stream = snd_enum_to_int(stream); req->stream = stream;
req->mode = mode; req->mode = mode;
req->namelen = snamelen; req->namelen = snamelen;
err = write(sock, req, reqlen); err = write(sock, req, reqlen);

14
src/rawmidi/rawmidi.c
View file

@ -60,9 +60,9 @@ static int snd_rawmidi_params_default(snd_rawmidi_t *rawmidi, snd_rawmidi_params
return 0; return 0;
} }
int snd_rawmidi_open_conf(snd_rawmidi_t **inputp, snd_rawmidi_t **outputp, static int snd_rawmidi_open_conf(snd_rawmidi_t **inputp, snd_rawmidi_t **outputp,
const char *name, snd_config_t *rawmidi_root, const char *name, snd_config_t *rawmidi_root,
snd_config_t *rawmidi_conf, int mode) snd_config_t *rawmidi_conf, int mode)
{ {
const char *str; const char *str;
char buf[256]; char buf[256];
@ -159,8 +159,8 @@ int snd_rawmidi_open_conf(snd_rawmidi_t **inputp, snd_rawmidi_t **outputp,
return 0; return 0;
} }
int snd_rawmidi_open_noupdate(snd_rawmidi_t **inputp, snd_rawmidi_t **outputp, static int snd_rawmidi_open_noupdate(snd_rawmidi_t **inputp, snd_rawmidi_t **outputp,
snd_config_t *root, const char *name, int mode) snd_config_t *root, const char *name, int mode)
{ {
int err; int err;
snd_config_t *rawmidi_conf; snd_config_t *rawmidi_conf;
@ -385,7 +385,7 @@ unsigned int snd_rawmidi_info_get_subdevice(const snd_rawmidi_info_t *info)
snd_rawmidi_stream_t snd_rawmidi_info_get_stream(const snd_rawmidi_info_t *info) snd_rawmidi_stream_t snd_rawmidi_info_get_stream(const snd_rawmidi_info_t *info)
{ {
assert(info); assert(info);
return snd_int_to_enum(info->stream); return info->stream;
} }
/** /**
@ -495,7 +495,7 @@ void snd_rawmidi_info_set_subdevice(snd_rawmidi_info_t *info, unsigned int val)
void snd_rawmidi_info_set_stream(snd_rawmidi_info_t *info, snd_rawmidi_stream_t val) void snd_rawmidi_info_set_stream(snd_rawmidi_info_t *info, snd_rawmidi_stream_t val)
{ {
assert(info); assert(info);
info->stream = snd_enum_to_int(val); info->stream = val;
} }
/** /**

10
src/rawmidi/rawmidi_hw.c
View file

@ -75,7 +75,7 @@ static int snd_rawmidi_hw_nonblock(snd_rawmidi_t *rmidi, int nonblock)
static int snd_rawmidi_hw_info(snd_rawmidi_t *rmidi, snd_rawmidi_info_t * info) static int snd_rawmidi_hw_info(snd_rawmidi_t *rmidi, snd_rawmidi_info_t * info)
{ {
snd_rawmidi_hw_t *hw = rmidi->private_data; snd_rawmidi_hw_t *hw = rmidi->private_data;
info->stream = snd_enum_to_int(rmidi->stream); info->stream = rmidi->stream;
if (ioctl(hw->fd, SNDRV_RAWMIDI_IOCTL_INFO, info) < 0) { if (ioctl(hw->fd, SNDRV_RAWMIDI_IOCTL_INFO, info) < 0) {
SYSERR("SNDRV_RAWMIDI_IOCTL_INFO failed"); SYSERR("SNDRV_RAWMIDI_IOCTL_INFO failed");
return -errno; return -errno;
@ -86,7 +86,7 @@ static int snd_rawmidi_hw_info(snd_rawmidi_t *rmidi, snd_rawmidi_info_t * info)
static int snd_rawmidi_hw_params(snd_rawmidi_t *rmidi, snd_rawmidi_params_t * params) static int snd_rawmidi_hw_params(snd_rawmidi_t *rmidi, snd_rawmidi_params_t * params)
{ {
snd_rawmidi_hw_t *hw = rmidi->private_data; snd_rawmidi_hw_t *hw = rmidi->private_data;
params->stream = snd_enum_to_int(rmidi->stream); params->stream = rmidi->stream;
if (ioctl(hw->fd, SNDRV_RAWMIDI_IOCTL_PARAMS, params) < 0) { if (ioctl(hw->fd, SNDRV_RAWMIDI_IOCTL_PARAMS, params) < 0) {
SYSERR("SNDRV_RAWMIDI_IOCTL_PARAMS failed"); SYSERR("SNDRV_RAWMIDI_IOCTL_PARAMS failed");
return -errno; return -errno;
@ -97,7 +97,7 @@ static int snd_rawmidi_hw_params(snd_rawmidi_t *rmidi, snd_rawmidi_params_t * pa
static int snd_rawmidi_hw_status(snd_rawmidi_t *rmidi, snd_rawmidi_status_t * status) static int snd_rawmidi_hw_status(snd_rawmidi_t *rmidi, snd_rawmidi_status_t * status)
{ {
snd_rawmidi_hw_t *hw = rmidi->private_data; snd_rawmidi_hw_t *hw = rmidi->private_data;
status->stream = snd_enum_to_int(rmidi->stream); status->stream = rmidi->stream;
if (ioctl(hw->fd, SNDRV_RAWMIDI_IOCTL_STATUS, status) < 0) { if (ioctl(hw->fd, SNDRV_RAWMIDI_IOCTL_STATUS, status) < 0) {
SYSERR("SNDRV_RAWMIDI_IOCTL_STATUS failed"); SYSERR("SNDRV_RAWMIDI_IOCTL_STATUS failed");
return -errno; return -errno;
@ -108,7 +108,7 @@ static int snd_rawmidi_hw_status(snd_rawmidi_t *rmidi, snd_rawmidi_status_t * st
static int snd_rawmidi_hw_drop(snd_rawmidi_t *rmidi) static int snd_rawmidi_hw_drop(snd_rawmidi_t *rmidi)
{ {
snd_rawmidi_hw_t *hw = rmidi->private_data; snd_rawmidi_hw_t *hw = rmidi->private_data;
int str = snd_enum_to_int(rmidi->stream); int str = rmidi->stream;
if (ioctl(hw->fd, SNDRV_RAWMIDI_IOCTL_DROP, &str) < 0) { if (ioctl(hw->fd, SNDRV_RAWMIDI_IOCTL_DROP, &str) < 0) {
SYSERR("SNDRV_RAWMIDI_IOCTL_DROP failed"); SYSERR("SNDRV_RAWMIDI_IOCTL_DROP failed");
return -errno; return -errno;
@ -119,7 +119,7 @@ static int snd_rawmidi_hw_drop(snd_rawmidi_t *rmidi)
static int snd_rawmidi_hw_drain(snd_rawmidi_t *rmidi) static int snd_rawmidi_hw_drain(snd_rawmidi_t *rmidi)
{ {
snd_rawmidi_hw_t *hw = rmidi->private_data; snd_rawmidi_hw_t *hw = rmidi->private_data;
int str = snd_enum_to_int(rmidi->stream); int str = rmidi->stream;
if (ioctl(hw->fd, SNDRV_RAWMIDI_IOCTL_DRAIN, &str) < 0) { if (ioctl(hw->fd, SNDRV_RAWMIDI_IOCTL_DRAIN, &str) < 0) {
SYSERR("SNDRV_RAWMIDI_IOCTL_DRAIN failed"); SYSERR("SNDRV_RAWMIDI_IOCTL_DRAIN failed");
return -errno; return -errno;

152
src/seq/seq_midi_event.c
View file

@ -1,3 +1,10 @@
/**
* \file seq/seq_midi_event.c
* \author Takashi Iwai <tiwai@suse.de>
* \author Jaroslav Kysela <perex@suse.cz>
* \date 2000-2001
*/
/* /*
* MIDI byte <-> sequencer event coder * MIDI byte <-> sequencer event coder
* *
@ -22,6 +29,7 @@
#include <malloc.h> #include <malloc.h>
#include "local.h" #include "local.h"
#ifndef DOC_HIDDEN
/* midi status */ /* midi status */
struct snd_midi_event { struct snd_midi_event {
@ -47,6 +55,8 @@ struct snd_midi_event {
typedef void (*event_encode_t)(snd_midi_event_t *dev, snd_seq_event_t *ev); typedef void (*event_encode_t)(snd_midi_event_t *dev, snd_seq_event_t *ev);
typedef void (*event_decode_t)(snd_seq_event_t *ev, unsigned char *buf); typedef void (*event_decode_t)(snd_seq_event_t *ev, unsigned char *buf);
#endif /* DOC_HIDDEN */
/* /*
* prototypes * prototypes
*/ */
@ -72,31 +82,31 @@ static struct status_event_list_t {
event_decode_t decode; event_decode_t decode;
} status_event[] = { } status_event[] = {
/* 0x80 - 0xf0 */ /* 0x80 - 0xf0 */
{SNDRV_SEQ_EVENT_NOTEOFF, 2, note_event, note_decode}, {SND_SEQ_EVENT_NOTEOFF, 2, note_event, note_decode},
{SNDRV_SEQ_EVENT_NOTEON, 2, note_event, note_decode}, {SND_SEQ_EVENT_NOTEON, 2, note_event, note_decode},
{SNDRV_SEQ_EVENT_KEYPRESS, 2, note_event, note_decode}, {SND_SEQ_EVENT_KEYPRESS, 2, note_event, note_decode},
{SNDRV_SEQ_EVENT_CONTROLLER, 2, two_param_ctrl_event, two_param_decode}, {SND_SEQ_EVENT_CONTROLLER, 2, two_param_ctrl_event, two_param_decode},
{SNDRV_SEQ_EVENT_PGMCHANGE, 1, one_param_ctrl_event, one_param_decode}, {SND_SEQ_EVENT_PGMCHANGE, 1, one_param_ctrl_event, one_param_decode},
{SNDRV_SEQ_EVENT_CHANPRESS, 1, one_param_ctrl_event, one_param_decode}, {SND_SEQ_EVENT_CHANPRESS, 1, one_param_ctrl_event, one_param_decode},
{SNDRV_SEQ_EVENT_PITCHBEND, 2, pitchbend_ctrl_event, pitchbend_decode}, {SND_SEQ_EVENT_PITCHBEND, 2, pitchbend_ctrl_event, pitchbend_decode},
{SNDRV_SEQ_EVENT_NONE, 0, NULL, NULL}, /* 0xf0 */ {SND_SEQ_EVENT_NONE, 0, NULL, NULL}, /* 0xf0 */
/* 0xf0 - 0xff */ /* 0xf0 - 0xff */
{SNDRV_SEQ_EVENT_SYSEX, 1, NULL, NULL}, /* sysex: 0xf0 */ {SND_SEQ_EVENT_SYSEX, 1, NULL, NULL}, /* sysex: 0xf0 */
{SNDRV_SEQ_EVENT_QFRAME, 1, one_param_event, one_param_decode}, /* 0xf1 */ {SND_SEQ_EVENT_QFRAME, 1, one_param_event, one_param_decode}, /* 0xf1 */
{SNDRV_SEQ_EVENT_SONGPOS, 2, songpos_event, songpos_decode}, /* 0xf2 */ {SND_SEQ_EVENT_SONGPOS, 2, songpos_event, songpos_decode}, /* 0xf2 */
{SNDRV_SEQ_EVENT_SONGSEL, 1, one_param_event, one_param_decode}, /* 0xf3 */ {SND_SEQ_EVENT_SONGSEL, 1, one_param_event, one_param_decode}, /* 0xf3 */
{SNDRV_SEQ_EVENT_NONE, 0, NULL, NULL}, /* 0xf4 */ {SND_SEQ_EVENT_NONE, 0, NULL, NULL}, /* 0xf4 */
{SNDRV_SEQ_EVENT_NONE, 0, NULL, NULL}, /* 0xf5 */ {SND_SEQ_EVENT_NONE, 0, NULL, NULL}, /* 0xf5 */
{SNDRV_SEQ_EVENT_TUNE_REQUEST, 0, NULL, NULL}, /* 0xf6 */ {SND_SEQ_EVENT_TUNE_REQUEST, 0, NULL, NULL}, /* 0xf6 */
{SNDRV_SEQ_EVENT_NONE, 0, NULL, NULL}, /* 0xf7 */ {SND_SEQ_EVENT_NONE, 0, NULL, NULL}, /* 0xf7 */
{SNDRV_SEQ_EVENT_CLOCK, 0, NULL, NULL}, /* 0xf8 */ {SND_SEQ_EVENT_CLOCK, 0, NULL, NULL}, /* 0xf8 */
{SNDRV_SEQ_EVENT_NONE, 0, NULL, NULL}, /* 0xf9 */ {SND_SEQ_EVENT_NONE, 0, NULL, NULL}, /* 0xf9 */
{SNDRV_SEQ_EVENT_START, 0, NULL, NULL}, /* 0xfa */ {SND_SEQ_EVENT_START, 0, NULL, NULL}, /* 0xfa */
{SNDRV_SEQ_EVENT_CONTINUE, 0, NULL, NULL}, /* 0xfb */ {SND_SEQ_EVENT_CONTINUE, 0, NULL, NULL}, /* 0xfb */
{SNDRV_SEQ_EVENT_STOP, 0, NULL, NULL}, /* 0xfc */ {SND_SEQ_EVENT_STOP, 0, NULL, NULL}, /* 0xfc */
{SNDRV_SEQ_EVENT_NONE, 0, NULL, NULL}, /* 0xfd */ {SND_SEQ_EVENT_NONE, 0, NULL, NULL}, /* 0xfd */
{SNDRV_SEQ_EVENT_SENSING, 0, NULL, NULL}, /* 0xfe */ {SND_SEQ_EVENT_SENSING, 0, NULL, NULL}, /* 0xfe */
{SNDRV_SEQ_EVENT_RESET, 0, NULL, NULL}, /* 0xff */ {SND_SEQ_EVENT_RESET, 0, NULL, NULL}, /* 0xff */
}; };
static int extra_decode_ctrl14(snd_midi_event_t *dev, unsigned char *buf, int len, snd_seq_event_t *ev); static int extra_decode_ctrl14(snd_midi_event_t *dev, unsigned char *buf, int len, snd_seq_event_t *ev);
@ -105,17 +115,21 @@ static struct extra_event_list_t {
int event; int event;
int (*decode)(snd_midi_event_t *dev, unsigned char *buf, int len, snd_seq_event_t *ev); int (*decode)(snd_midi_event_t *dev, unsigned char *buf, int len, snd_seq_event_t *ev);
} extra_event[] = { } extra_event[] = {
{SNDRV_SEQ_EVENT_CONTROL14, extra_decode_ctrl14}, {SND_SEQ_EVENT_CONTROL14, extra_decode_ctrl14},
/*{SNDRV_SEQ_EVENT_NONREGPARAM, extra_decode_nrpn},*/ /*{SND_SEQ_EVENT_NONREGPARAM, extra_decode_nrpn},*/
/*{SNDRV_SEQ_EVENT_REGPARAM, extra_decode_rpn},*/ /*{SND_SEQ_EVENT_REGPARAM, extra_decode_rpn},*/
}; };
#define numberof(ary) (sizeof(ary)/sizeof(ary[0])) #define numberof(ary) (sizeof(ary)/sizeof(ary[0]))
/* /**
* new/delete record * \brief Initialize MIDI event parser
* \param bufsize buffer size for MIDI message
* \param rdev allocated MIDI event parser
* \return 0 on success otherwise a negative error code
*
* Allocates and initializes MIDI event parser.
*/ */
int snd_midi_event_new(size_t bufsize, snd_midi_event_t **rdev) int snd_midi_event_new(size_t bufsize, snd_midi_event_t **rdev)
{ {
snd_midi_event_t *dev; snd_midi_event_t *dev;
@ -136,6 +150,13 @@ int snd_midi_event_new(size_t bufsize, snd_midi_event_t **rdev)
return 0; return 0;
} }
/**
* \brief Free MIDI event parser
* \param rdev MIDI event parser
* \return 0 on success otherwise a negative error code
*
* Frees MIDI event parser.
*/
void snd_midi_event_free(snd_midi_event_t *dev) void snd_midi_event_free(snd_midi_event_t *dev)
{ {
if (dev != NULL) { if (dev != NULL) {
@ -155,24 +176,50 @@ inline static void reset_encode(snd_midi_event_t *dev)
dev->type = 0; dev->type = 0;
} }
/**
* \brief Reset MIDI encode parser
* \param dev MIDI event parser
* \return 0 on success otherwise a negative error code
*
* Resets MIDI encode parser
*/
void snd_midi_event_reset_encode(snd_midi_event_t *dev) void snd_midi_event_reset_encode(snd_midi_event_t *dev)
{ {
reset_encode(dev); reset_encode(dev);
} }
/**
* \brief Reset MIDI decode parser
* \param dev MIDI event parser
* \return 0 on success otherwise a negative error code
*
* Resets MIDI decode parser
*/
void snd_midi_event_reset_decode(snd_midi_event_t *dev) void snd_midi_event_reset_decode(snd_midi_event_t *dev)
{ {
dev->lastcmd = 0xff; dev->lastcmd = 0xff;
} }
/**
* \brief Initializes MIDI parsers
* \param dev MIDI event parser
* \return 0 on success otherwise a negative error code
*
* Initializes MIDI parsers (both encode and decode)
*/
void snd_midi_event_init(snd_midi_event_t *dev) void snd_midi_event_init(snd_midi_event_t *dev)
{ {
snd_midi_event_reset_encode(dev); snd_midi_event_reset_encode(dev);
snd_midi_event_reset_decode(dev); snd_midi_event_reset_decode(dev);
} }
/* /**
* resize buffer * \brief Resize MIDI message (event) buffer
* \param dev MIDI event parser
* \param bufsize new requested buffer size
* \return 0 on success otherwise a negative error code
*
* Resizes MIDI message (event) buffer.
*/ */
int snd_midi_event_resize_buffer(snd_midi_event_t *dev, size_t bufsize) int snd_midi_event_resize_buffer(snd_midi_event_t *dev, size_t bufsize)
{ {
@ -192,16 +239,24 @@ int snd_midi_event_resize_buffer(snd_midi_event_t *dev, size_t bufsize)
return 0; return 0;
} }
/* /**
* read bytes and encode to sequencer event if finished * \brief Read bytes and encode to sequencer event if finished
* return the size of encoded bytes * \param dev MIDI event parser
* \param buf MIDI byte stream
* \param count count of bytes of MIDI byte stream to encode
* \param ev Result - sequencer event
* \return count of encoded bytes otherwise a negative error code
*
* Read bytes and encode to sequencer event if finished.
* If complete sequencer event is available, ev->type is not
* equal to #SND_SEQ_EVENT_NONE.
*/ */
long snd_midi_event_encode(snd_midi_event_t *dev, unsigned char *buf, long count, snd_seq_event_t *ev) long snd_midi_event_encode(snd_midi_event_t *dev, unsigned char *buf, long count, snd_seq_event_t *ev)
{ {
long result = 0; long result = 0;
int rc; int rc;
ev->type = SNDRV_SEQ_EVENT_NONE; ev->type = SND_SEQ_EVENT_NONE;
while (count-- > 0) { while (count-- > 0) {
rc = snd_midi_event_encode_byte(dev, *buf++, ev); rc = snd_midi_event_encode_byte(dev, *buf++, ev);
@ -215,11 +270,14 @@ long snd_midi_event_encode(snd_midi_event_t *dev, unsigned char *buf, long count
return result; return result;
} }
/* /**
* read one byte and encode to sequencer event: * \brief Read one byte and encode to sequencer event if finished
* return 1 if MIDI bytes are encoded to an event * \param dev MIDI event parser
* 0 data is not finished * \param c a byte of MIDI stream
* negative for error * \param ev Result - sequencer event
* \return 1 - sequencer event is completed, 0 - next byte is required for completion, otherwise a negative error code
*
* Read byte and encode to sequencer event if finished.
*/ */
int snd_midi_event_encode_byte(snd_midi_event_t *dev, int c, snd_seq_event_t *ev) int snd_midi_event_encode_byte(snd_midi_event_t *dev, int c, snd_seq_event_t *ev)
{ {
@ -323,9 +381,15 @@ static void songpos_event(snd_midi_event_t *dev, snd_seq_event_t *ev)
ev->data.control.value = (int)dev->buf[2] * 128 + (int)dev->buf[1]; ev->data.control.value = (int)dev->buf[2] * 128 + (int)dev->buf[1];
} }
/* /**
* decode from a sequencer event to midi bytes * \brief Decode sequencer event to MIDI byte stream
* return the size of decoded midi events * \param dev MIDI event parser
* \param buf Result - MIDI byte stream
* \param count Available bytes in MIDI byte stream
* \param ev Event to decode
* \return count of decoded bytes otherwise a negative error code
*
* Decode sequencer event to MIDI byte stream.
*/ */
long snd_midi_event_decode(snd_midi_event_t *dev, unsigned char *buf, long count, snd_seq_event_t *ev) long snd_midi_event_decode(snd_midi_event_t *dev, unsigned char *buf, long count, snd_seq_event_t *ev)
{ {