Fix the warnings of doxygen parsing.
Add some missing documentation.
../src/output.c \
../src/conf.c \
../src/confmisc.c \
+ ../src/names.c \
+ ../src/shmarea.c \
+ ../src/userfile.c \
../src/control \
../src/mixer \
../src/pcm/pcm.c \
../src/pcm/pcm_dmix.c \
../src/pcm/pcm_dshare.c \
../src/pcm/pcm_dsnoop.c \
- ../src/pcm/pcm_direct.c \
../src/pcm/pcm_meter.c \
../src/pcm/pcm_ladspa.c \
../src/pcm/pcm_asym.c \
../src/pcm/pcm_extplug.c \
../src/pcm/pcm_ioplug.c \
../src/pcm/pcm_misc.c \
+ ../src/pcm/pcm_simple.c \
../src/rawmidi \
../src/timer \
../src/hwdep \
/* Names functions */
+/**
+ * Device-name list element
+ */
typedef struct snd_devname snd_devname_t;
+/**
+ * Device-name list element (definition)
+ */
struct snd_devname {
- char *name;
- char *comment;
- snd_devname_t *next;
+ char *name; /**< Device name string */
+ char *comment; /**< Comments */
+ snd_devname_t *next; /**< Next pointer */
};
int snd_names_list(const char *interface, snd_devname_t **list);
void snd_ctl_elem_info_set_name(snd_ctl_elem_info_t *obj, const char *val);
void snd_ctl_elem_info_set_index(snd_ctl_elem_info_t *obj, unsigned int val);
-int snd_ctl_elem_add_integer(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id, unsigned int count, long imin, long imax, long istep);;
-int snd_ctl_elem_add_integer64(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id, unsigned int count, long long imin, long long imax, long long istep);;
+int snd_ctl_elem_add_integer(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id, unsigned int count, long imin, long imax, long istep);
+int snd_ctl_elem_add_integer64(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id, unsigned int count, long long imin, long long imax, long long istep);
int snd_ctl_elem_add_boolean(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id, unsigned int count);
int snd_ctl_elem_add_iec958(snd_ctl_t *ctl, const snd_ctl_elem_id_t *id);
int snd_ctl_elem_remove(snd_ctl_t *ctl, snd_ctl_elem_id_t *id);
/**
* \brief set the tag for given event
* \param ev event record
- * \param tag event tag
+ * \param t event tag
*
* This macro sets the tag to the given event record.
*/
/**
* \brief set varusr data
* \param ev event instance
- * \param len length of the external data
- * \param ptr pointer of the external data
+ * \param datalen length of the external data
+ * \param dataptr pointer of the external data
*
* Sets the event length mode as variable user-space data and stores the data.
*
/** timer tstamp + event read structure */
typedef struct _snd_timer_tread {
- snd_timer_event_t event;
- snd_htimestamp_t tstamp;
- unsigned int val;
+ snd_timer_event_t event; /**< Timer event */
+ snd_htimestamp_t tstamp; /**< Time stamp of each event */
+ unsigned int val; /**< Event value */
} snd_timer_tread_t;
/** global timer - system */
\section confarg_define Defining arguments
-Arguments are defined using the id (key) \c @args and array values containing
+Arguments are defined using the id (key) \c \@args and array values containing
the string names of the arguments:
\code
\section confarg_type Defining argument types and default values
-An argument's type is specified with the id (key) \c @args and the argument
+An argument's type is specified with the id (key) \c \@args and the argument
name. The type and the default value are specified in the compound block:
\code
<P>The ALSA library can modify the configuration at runtime.
Several built-in functions are available.</P>
-<P>A function is defined with the id \c @func and the function name. All other
+<P>A function is defined with the id \c \@func and the function name. All other
values in the current compound are used as configuration for the function.
If the compound func.<function_name> is defined in the root node, then the
library and function from this compound configuration are used, otherwise
<P>The hook extension in the ALSA library allows expansion of configuration
nodes at run-time. The existence of a hook is determined by the
-presence of a @hooks compound node.</P>
+presence of a \@hooks compound node.</P>
<P>This example defines a hook which loads two configuration files at the
beginning:</P>
*/
snd_config_t *snd_config = NULL;
+#ifndef DOC_HIDDEN
struct finfo {
char *name;
dev_t dev;
unsigned int count;
struct finfo *finfo;
};
+#endif /* DOC_HIDDEN */
static snd_config_update_t *snd_config_global_update = NULL;
/**
* \brief Updates a configuration tree by rereading the configuration files (if needed).
- * \param top Address of the handle to the top level node.
- * \param update Address of a pointer to private update information.
+ * \param _top Address of the handle to the top level node.
+ * \param _update Address of a pointer to private update information.
* \param cfgs A list of configuration file names, delimited with ':'.
* If \p cfgs is set to \c NULL, the default global configuration
* file is used ("/usr/share/alsa/alsa.conf").
* \brief Searches for a definition in a configuration tree, using aliases and expanding hooks and arguments.
* \param config Handle to the configuration (sub)tree to search.
* \param base Implicit key base, or \c NULL for none.
- * \param key Key suffix.
+ * \param name Key suffix.
* \param result The function puts the handle to the expanded found node at
* the address specified by \p result.
* \return Zero if successful, otherwise a negative error code.
/**
* \brief Lock CTL element
* \param ctl CTL handle
- * \param control CTL element id pointer
+ * \param id CTL element id pointer
* \return 0 on success otherwise a negative error code
*/
int snd_ctl_elem_lock(snd_ctl_t *ctl, snd_ctl_elem_id_t *id)
/**
* \brief Unlock CTL element
* \param ctl CTL handle
- * \param control CTL element id pointer
+ * \param id CTL element id pointer
* \return 0 on success otherwise a negative error code
*/
int snd_ctl_elem_unlock(snd_ctl_t *ctl, snd_ctl_elem_id_t *id)
/**
* \brief frees a previously allocated #snd_ctl_elem_id_t
- * \param pointer to object to free
+ * \param obj pointer to object to free
*/
void snd_ctl_elem_id_free(snd_ctl_elem_id_t *obj)
{
/**
* \brief frees a previously allocated #snd_ctl_card_info_t
- * \param pointer to object to free
+ * \param obj pointer to object to free
*/
void snd_ctl_card_info_free(snd_ctl_card_info_t *obj)
{
/**
* \brief frees a previously allocated #snd_ctl_event_t
- * \param pointer to object to free
+ * \param obj pointer to object to free
*/
void snd_ctl_event_free(snd_ctl_event_t *obj)
{
/**
* \brief frees a previously allocated #snd_ctl_elem_list_t
- * \param pointer to object to free
+ * \param obj pointer to object to free
*/
void snd_ctl_elem_list_free(snd_ctl_elem_list_t *obj)
{
/**
* \brief frees a previously allocated #snd_ctl_elem_info_t
- * \param pointer to object to free
+ * \param obj pointer to object to free
*/
void snd_ctl_elem_info_free(snd_ctl_elem_info_t *obj)
{
/**
* \brief Get specified of dimension width for given element
* \param obj CTL element id/info
+ * \param idx The dimension index
* \return zero value if no dimension width is defined, otherwise positive value with with of specified dimension
*/
#ifndef DOXYGEN
/**
* \brief frees a previously allocated #snd_ctl_elem_value_t
- * \param pointer to object to free
+ * \param obj pointer to object to free
*/
void snd_ctl_elem_value_free(snd_ctl_elem_value_t *obj)
{
/**
* \brief Set CTL element #SND_CTL_ELEM_TYPE_BYTES value
- * \param ctl CTL handle
+ * \param obj CTL handle
* \param data Bytes value
* \param size Size in bytes
*/
/**
* \brief Get value for a #SND_CTL_ELEM_TYPE_IEC958 CTL element id/value
* \param obj CTL element id/value
- * \param Pointer to returned CTL element value
+ * \param ptr Pointer to returned CTL element value
*/
void snd_ctl_elem_value_get_iec958(const snd_ctl_elem_value_t *obj, snd_aes_iec958_t *ptr)
{
/**
* \brief Set value for a #SND_CTL_ELEM_TYPE_IEC958 CTL element id/value
* \param obj CTL element id/value
- * \param Pointer to CTL element value
+ * \param ptr Pointer to CTL element value
*/
void snd_ctl_elem_value_set_iec958(snd_ctl_elem_value_t *obj, const snd_aes_iec958_t *ptr)
{
#define F_SETSIG 10
#endif
+#ifndef DOC_HIDDEN
#define SNDRV_FILE_CONTROL "/dev/snd/controlC%i"
#define SNDRV_CTL_VERSION_MAX SNDRV_PROTOCOL_VERSION(2, 0, 3)
int card;
int fd;
} snd_ctl_hw_t;
+#endif /* DOC_HIDDEN */
static int snd_ctl_hw_close(snd_ctl_t *handle)
{
const char *_snd_module_control_shm = "";
#endif
+#ifndef DOC_HIDDEN
typedef struct {
int socket;
volatile snd_ctl_shm_ctrl_t *ctrl;
} snd_ctl_shm_t;
+#endif
static int snd_ctl_shm_action(snd_ctl_t *ctl)
{
/**
* \brief get returned events from poll descriptors
- * \param ctl HCTL handle
+ * \param hctl HCTL handle
* \param pfds array of poll descriptors
* \param nfds count of poll descriptors
* \param revents returned events
#include <ctype.h>
#include "local.h"
+#ifndef DOC_HIDDEN
typedef struct {
unsigned int lock: 1;
unsigned int preserve: 1;
snd_ctl_t *ctl;
struct list_head elems;
};
+#endif /* DOC_HIDDEN */
static int free_elems(snd_sctl_t *h)
{
* FIXME: add reference counter and proper locking
*/
+#ifndef DOC_HIDDEN
struct dlobj_cache {
const char *name;
void *obj;
free(c);
}
}
+#endif
assert(0);
}
+/**
+ * The ALSA error message handler
+ */
snd_lib_error_handler_t snd_err_msg = snd_err_msg_default;
#endif
* \param hwdep Returned handle (NULL if not wanted)
* \param name ASCII identifier of the HwDep handle
* \param mode Open mode
+ * \param lconf The local configuration tree
* \return 0 on success otherwise a negative error code
*
* Opens a new connection to the HwDep interface specified with
/**
* \brief allocate a new snd_hwdep_info_t structure
- * \param ptr returned pointer
+ * \param info returned pointer
* \return 0 on success otherwise a negative error code if fails
*
* Allocates a new snd_hwdep_info_t structure using the standard
/**
* \brief get hwdep card number
- * \param info pointer to a snd_hwdep_info_t structure
+ * \param obj pointer to a snd_hwdep_info_t structure
* \return hwdep card number
*/
int snd_hwdep_info_get_card(const snd_hwdep_info_t *obj)
/**
* \brief get hwdep driver identifier
- * \param info pointer to a snd_hwdep_info_t structure
+ * \param obj pointer to a snd_hwdep_info_t structure
* \return hwdep driver identifier
*/
const char *snd_hwdep_info_get_id(const snd_hwdep_info_t *obj)
/**
* \brief get hwdep driver name
- * \param info pointer to a snd_hwdep_info_t structure
+ * \param obj pointer to a snd_hwdep_info_t structure
* \return hwdep driver name
*/
const char *snd_hwdep_info_get_name(const snd_hwdep_info_t *obj)
/**
* \brief get hwdep protocol interface
- * \param info pointer to a snd_hwdep_info_t structure
+ * \param obj pointer to a snd_hwdep_info_t structure
* \return hwdep protocol interface
*/
snd_hwdep_iface_t snd_hwdep_info_get_iface(const snd_hwdep_info_t *obj)
/**
* \brief set hwdep device number
- * \param info pointer to a snd_hwdep_info_t structure
+ * \param obj pointer to a snd_hwdep_info_t structure
* \param val hwdep device
*/
void snd_hwdep_info_set_device(snd_hwdep_info_t *obj, unsigned int val)
/**
* \brief allocate a new snd_hwdep_dsp_status_t structure
- * \param ptr returned pointer
+ * \param info returned pointer
* \return 0 on success otherwise a negative error code if fails
*
* Allocates a new snd_hwdep_dsp_status_t structure using the standard
/**
* \brief get the driver version of dsp loader
- * \param info pointer to a snd_hwdep_dsp_status_t structure
+ * \param obj pointer to a snd_hwdep_dsp_status_t structure
* \return the driver version
*/
unsigned int snd_hwdep_dsp_status_get_version(const snd_hwdep_dsp_status_t *obj)
/**
* \brief get the driver id of dsp loader
- * \param info pointer to a snd_hwdep_dsp_status_t structure
+ * \param obj pointer to a snd_hwdep_dsp_status_t structure
* \return the driver id string
*/
const char *snd_hwdep_dsp_status_get_id(const snd_hwdep_dsp_status_t *obj)
/**
* \brief get number of dsp blocks
- * \param info pointer to a snd_hwdep_dsp_status_t structure
+ * \param obj pointer to a snd_hwdep_dsp_status_t structure
* \return number of dsp blocks
*/
unsigned int snd_hwdep_dsp_status_get_num_dsps(const snd_hwdep_dsp_status_t *obj)
/**
* \brief get the chip status of dsp loader
- * \param info pointer to a snd_hwdep_dsp_status_t structure
+ * \param obj pointer to a snd_hwdep_dsp_status_t structure
* \return non-zero if all DSP blocks are loaded and the chip is ready
*/
unsigned int snd_hwdep_dsp_status_get_chip_ready(const snd_hwdep_dsp_status_t *obj)
/**
* \brief allocate a new snd_hwdep_dsp_image_t structure
- * \param ptr returned pointer
+ * \param info returned pointer
* \return 0 on success otherwise a negative error code if fails
*
* Allocates a new snd_hwdep_dsp_image_t structure using the standard
/**
* \brief get the DSP block index
- * \param info pointer to a snd_hwdep_dsp_image_t structure
+ * \param obj pointer to a snd_hwdep_dsp_image_t structure
* \return the index of the DSP block
*/
unsigned int snd_hwdep_dsp_image_get_index(const snd_hwdep_dsp_image_t *obj)
/**
* \brief get the name of the DSP block
- * \param info pointer to a snd_hwdep_dsp_image_t structure
+ * \param obj pointer to a snd_hwdep_dsp_image_t structure
* \return the name string of the DSP block
*/
const char *snd_hwdep_dsp_image_get_name(const snd_hwdep_dsp_image_t *obj)
/**
* \brief get the length of the DSP block
- * \param info pointer to a snd_hwdep_dsp_image_t structure
+ * \param obj pointer to a snd_hwdep_dsp_image_t structure
* \return the length of the DSP block in bytes
*/
size_t snd_hwdep_dsp_image_get_length(const snd_hwdep_dsp_image_t *obj)
/**
* \brief get the image pointer of the DSP block
- * \param info pointer to a snd_hwdep_dsp_image_t structure
+ * \param obj pointer to a snd_hwdep_dsp_image_t structure
* \return the image pointer of the DSP block
*/
const void *snd_hwdep_dsp_image_get_image(const snd_hwdep_dsp_image_t *obj)
/**
* \brief set the DSP block index
- * \param info pointer to a snd_hwdep_dsp_image_t structure
+ * \param obj pointer to a snd_hwdep_dsp_image_t structure
* \param index the index value to set
*/
void snd_hwdep_dsp_image_set_index(snd_hwdep_dsp_image_t *obj, unsigned int index)
/**
* \brief set the name of the DSP block
- * \param info pointer to a snd_hwdep_dsp_image_t structure
+ * \param obj pointer to a snd_hwdep_dsp_image_t structure
* \param name the name string
*/
void snd_hwdep_dsp_image_set_name(snd_hwdep_dsp_image_t *obj, const char *name)
/**
* \brief set the DSP block length
- * \param info pointer to a snd_hwdep_dsp_image_t structure
+ * \param obj pointer to a snd_hwdep_dsp_image_t structure
* \param length the length of the DSP block
*/
void snd_hwdep_dsp_image_set_length(snd_hwdep_dsp_image_t *obj, size_t length)
/**
* \brief set the DSP block image pointer
- * \param info pointer to a snd_hwdep_dsp_image_t structure
+ * \param obj pointer to a snd_hwdep_dsp_image_t structure
* \param image the DSP image pointer
*/
void snd_hwdep_dsp_image_set_image(snd_hwdep_dsp_image_t *obj, void *image)
* \return Pointer to the buffer if successful, otherwise \c NULL.
*
* Like \c fgets, the returned string is zero-terminated, and contains
- * the new-line character \c '\n' if the line fits into the buffer.
+ * the new-line character \c '\\n' if the line fits into the buffer.
*/
char *snd_input_gets(snd_input_t *input, char *str, size_t size)
{
* at the address specified by \p inputp.
* \param fp The \c FILE pointer to read from.
* Reading begins at the current file position.
- * \param close Close flag. Set this to 1 if #snd_input_close should close
+ * \param _close Close flag. Set this to 1 if #snd_input_close should close
* \p fp by calling \c fclose.
* \return Zero if successful, otherwise a negative error code.
*/
#include <linux/version.h>
#if LINUX_VERSION_CODE == KERNEL_VERSION(2,6,9)
#include <asm/types.h>
+#ifndef DOC_HIDDEN
#define __le64 __u64
#define __le32 __u32
#define __le16 __u16
#define __be64 __u64
#define __be32 __u32
#define __be16 __u16
+#endif
#endif /* linux 2.6.9 workaround */
#include <asm/byteorder.h>
#include <sound/ainstr_fm.h>
#include <linux/version.h>
#if LINUX_VERSION_CODE == KERNEL_VERSION(2,6,9)
#include <asm/types.h>
+#ifndef DOC_HIDDEN
#define __le64 __u64
#define __le32 __u32
#define __le16 __u16
#define __be64 __u64
#define __be32 __u32
#define __be16 __u16
+#endif
#endif /* linux 2.6.9 workaround */
#include <sound/ainstr_iw.h>
#include <linux/version.h>
#if LINUX_VERSION_CODE == KERNEL_VERSION(2,6,9)
#include <asm/types.h>
+#ifndef DOC_HIDDEN
#define __le64 __u64
#define __le32 __u32
#define __le16 __u16
#define __be64 __u64
#define __be32 __u32
#define __be16 __u16
+#endif
#endif /* linux 2.6.9 workaround */
#include <asm/byteorder.h>
#include <sound/ainstr_simple.h>
/**
* \brief Set callback function for a mixer
- * \param mixer mixer handle
- * \param callback callback function
+ * \param obj mixer handle
+ * \param val callback function
*/
void snd_mixer_set_callback(snd_mixer_t *obj, snd_mixer_callback_t val)
{
/**
* \brief Set callback private value for a mixer
- * \param mixer mixer handle
- * \param callback_private callback private value
+ * \param obj mixer handle
+ * \param val callback private value
*/
void snd_mixer_set_callback_private(snd_mixer_t *obj, void * val)
{
/**
* \brief Get callback private value for a mixer
- * \param mixer mixer handle
+ * \param obj mixer handle
* \return callback private value
*/
void * snd_mixer_get_callback_private(const snd_mixer_t *obj)
/**
* \brief Get elements count for a mixer
- * \param mixer mixer handle
+ * \param obj mixer handle
* \return elements count
*/
unsigned int snd_mixer_get_count(const snd_mixer_t *obj)
/**
* \brief frees a previously allocated #snd_mixer_selem_id_t
- * \param pointer to object to free
+ * \param obj pointer to object to free
*/
void snd_mixer_selem_id_free(snd_mixer_selem_id_t *obj)
{
#include <locale.h>
#include "local.h"
+#ifndef DOC_HIDDEN
#define ALSA_NAMES_ENV "ALSA_NAMES_FILE"
#define ALSA_NAMES_PATH1 "/etc/asound.names"
#define ALSA_NAMES_PATH2 "~/.asoundnm"
+#endif
static int names_parse(snd_config_t *top, const char *interface, snd_devname_t **list)
{
return err >= 0 ? 0 : err;
}
+/**
+ * \brief Release the list of device names
+ * \param list the name list to release
+ *
+ * Releases the list of device names allocated via #snd_names_list().
+ */
void snd_names_list_free(snd_devname_t *list)
{
snd_devname_t *next;
* at the address specified by \p outputp.
* \param fp The \c FILE pointer to write to. Characters are written
* to the file starting at the current file position.
- * \param close Close flag. Set this to 1 if #snd_output_close should close
+ * \param _close Close flag. Set this to 1 if #snd_output_close should close
* \p fp by calling \c fclose.
* \return Zero if successful, otherwise a negative error code.
*/
/**
* \brief Pause/resume PCM
* \param pcm PCM handle
- * \param pause 0 = resume, 1 = pause
+ * \param enable 0 = resume, 1 = pause
* \return 0 on success otherwise a negative error code
*
* Note that this function works only on the hardware which supports
/**
* \brief get name of PCM access type
- * \param access PCM access type
+ * \param acc PCM access type
* \return ascii name of PCM access type
*/
const char *snd_pcm_access_name(snd_pcm_access_t acc)
/**
* \brief get name of PCM sample subformat
- * \param format PCM sample subformat
+ * \param subformat PCM sample subformat
* \return ascii name of PCM sample subformat
*/
const char *snd_pcm_subformat_name(snd_pcm_subformat_t subformat)
/**
* \brief Check, if hardware supports sample-resolution mmap for given configuration
- * \param param Configuration space
+ * \param params Configuration space
* \return Boolean value
* \retval 0 Hardware doesn't support sample-resolution mmap
* \retval 1 Hardware supports sample-resolution mmap
/**
* \brief Check, if hardware does double buffering for start/stop for given configuration
- * \param param Configuration space
+ * \param params Configuration space
* \return Boolean value
* \retval 0 Hardware doesn't do double buffering for start/stop
* \retval 1 Hardware does double buffering for start/stop
/**
* \brief Check, if hardware does double buffering for data transfers for given configuration
- * \param param Configuration space
+ * \param params Configuration space
* \return Boolean value
* \retval 0 Hardware doesn't do double buffering for data transfers
* \retval 1 Hardware does double buffering for data transfers
/**
* \brief Check, if hardware does block transfers for samples for given configuration
- * \param param Configuration space
+ * \param params Configuration space
* \return Boolean value
* \retval 0 Hardware doesn't block transfers
* \retval 1 Hardware does block transfers
/**
* \brief Check, if hardware supports overrange detection
- * \param param Configuration space
+ * \param params Configuration space
* \return Boolean value
* \retval 0 Hardware doesn't support overrange detection
* \retval 1 Hardware supports overrange detection
/**
* \brief Check, if hardware supports pause
- * \param param Configuration space
+ * \param params Configuration space
* \return Boolean value
* \retval 0 Hardware doesn't support pause
* \retval 1 Hardware supports pause
/**
* \brief Check, if hardware supports resume
- * \param param Configuration space
+ * \param params Configuration space
* \return Boolean value
* \retval 0 Hardware doesn't support resume
* \retval 1 Hardware supports resume
/**
* \brief Check, if hardware does half-duplex only
- * \param param Configuration space
+ * \param params Configuration space
* \return Boolean value
* \retval 0 Hardware doesn't do half-duplex
* \retval 1 Hardware does half-duplex
/**
* \brief Check, if hardware does joint-duplex (playback and capture are somewhat correlated)
- * \param param Configuration space
+ * \param params Configuration space
* \return Boolean value
* \retval 0 Hardware doesn't do joint-duplex
* \retval 1 Hardware does joint-duplex
/**
* \brief Check, if hardware supports synchronized start with sample resolution
- * \param param Configuration space
+ * \param params Configuration space
* \return Boolean value
* \retval 0 Hardware doesn't support synchronized start
* \retval 1 Hardware supports synchronized start
/**
* \brief frees a previously allocated #snd_pcm_access_mask_t
- * \param pointer to object to free
+ * \param obj pointer to object to free
*/
void snd_pcm_access_mask_free(snd_pcm_access_mask_t *obj)
{
/**
* \brief frees a previously allocated #snd_pcm_format_mask_t
- * \param pointer to object to free
+ * \param obj pointer to object to free
*/
void snd_pcm_format_mask_free(snd_pcm_format_mask_t *obj)
{
/**
* \brief frees a previously allocated #snd_pcm_subformat_mask_t
- * \param pointer to object to free
+ * \param obj pointer to object to free
*/
void snd_pcm_subformat_mask_free(snd_pcm_subformat_mask_t *obj)
{
/**
* \brief frees a previously allocated #snd_pcm_hw_params_t
- * \param pointer to object to free
+ * \param obj pointer to object to free
*/
void snd_pcm_hw_params_free(snd_pcm_hw_params_t *obj)
{
* \brief Restrict a configuration space to contain only its last access type
* \param pcm PCM handle
* \param params Configuration space
- * \param val Returned last access type
+ * \param access Returned last access type
* \return 0 otherwise a negative error code
*/
#ifndef DOXYGEN
* \param pcm PCM handle
* \param params Configuration space
* \param val approximate target rate / returned approximate set rate
+ * \param dir Sub unit direction
* \return 0 otherwise a negative error code if configuration space is empty
*
* target/chosen exact value is <,=,> val following dir (-1,0,1)
/**
* \brief Extract resample state from a configuration space
* \param pcm PCM handle
- * \param *val 0 = disable, 1 = enable rate resampling
+ * \param params Configuration space
+ * \param val 0 = disable, 1 = enable rate resampling
* \return 0 otherwise a negative error code
*/
int snd_pcm_hw_params_get_rate_resample(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int *val)
/**
* \brief Extract buffer accessibility from a configuration space
* \param pcm PCM handle
- * \param *val 0 = disable, 1 = enable exporting buffer
+ * \param params Configuration space
+ * \param val 0 = disable, 1 = enable exporting buffer
* \return 0 otherwise a negative error code
*/
int snd_pcm_hw_params_get_export_buffer(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int *val)
* \param pcm PCM handle
* \param params Configuration space
* \param val approximate target period duration in us / returned chosen approximate target period duration
+ * \param dir Sub unit direction
* \return 0 otherwise a negative error code if configuration space is empty
*
* target/chosen exact value is <,=,> val following dir (-1,0,1)
* \brief Restrict a configuration space to contain only its maximum period time
* \param pcm PCM handle
* \param params Configuration space
+ * \param val Returned maximum approximate period time
* \param dir Sub unit direction
* \return approximate period duration in us
- *
- * Actual exact value is <,=,> the approximate one following dir (-1, 0, 1)
*/
#ifndef DOXYGEN
int INTERNAL(snd_pcm_hw_params_set_period_time_last)(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int *val, int *dir)
* \param pcm PCM handle
* \param params Configuration space
* \param val approximate target period size in frames / returned chosen approximate target period size
+ * \param dir Sub unit direction
* \return 0 otherwise a negative error code if configuration space is empty
*
* target/chosen exact value is <,=,> val following dir (-1,0,1)
* \param pcm PCM handle
* \param params Configuration space
* \param val approximate target periods per buffer / returned chosen approximate target periods per buffer
+ * \param dir Sub unit direction
* \return 0 otherwise a negative error code if configuration space is empty
*
* target/chosen exact value is <,=,> val following dir (-1,0,1)
/**
* \brief Extract buffer time from a configuration space
* \param params Configuration space
- * \param approximate buffer duration in us
* \param val Returned buffer time in us
* \param dir Sub unit direction
* \return 0 otherwise a negative error code if not exactly one is present
* \param pcm PCM handle
* \param params Configuration space
* \param val approximate target buffer duration in us / returned chosen approximate target buffer duration
+ * \param dir Sub unit direction
* \return 0 otherwise a negative error code if configuration space is empty
*
* target/chosen exact value is <,=,> val following dir (-1,0,1)
* \brief Extract minimum buffer size from a configuration space
* \param params Configuration space
* \param val Returned approximate minimum buffer size in frames
- * \param dir Sub unit direction
* \return 0 otherwise a negative error code
- *
- * Exact value is <,=,> the returned one following dir (-1,0,1)
*/
#ifndef DOXYGEN
int INTERNAL(snd_pcm_hw_params_get_buffer_size_min)(const snd_pcm_hw_params_t *params, snd_pcm_uframes_t *val)
* \brief Extract maximum buffer size from a configuration space
* \param params Configuration space
* \param val Returned approximate maximum buffer size in frames
- * \param dir Sub unit direction
* \return 0 otherwise a negative error code
*
* Exact value is <,=,> the returned one following dir (-1,0,1)
* \param pcm PCM handle
* \param params Configuration space
* \param val buffer size in frames
- * \param dir Sub unit direction
* \return 0 if available a negative error code otherwise
*
* Wanted exact value is <,=,> val following dir (-1,0,1)
* \param pcm PCM handle
* \param params Configuration space
* \param val approximate minimum buffer size in frames (on return filled with actual minimum)
- * \param dir Sub unit direction (on return filled with actual direction)
* \return 0 otherwise a negative error code if configuration space would become empty
- *
- * Wanted/actual exact minimum is <,=,> val following dir (-1,0,1)
*/
int snd_pcm_hw_params_set_buffer_size_min(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_uframes_t *val)
{
* \param pcm PCM handle
* \param params Configuration space
* \param val approximate maximum buffer size in frames (on return filled with actual maximum)
- * \param dir Sub unit direction (on return filled with actual direction)
* \return 0 otherwise a negative error code if configuration space would become empty
- *
- * Wanted/actual exact minimum is <,=,> val following dir (-1,0,1)
*/
int snd_pcm_hw_params_set_buffer_size_max(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_uframes_t *val)
{
* \param pcm PCM handle
* \param params Configuration space
* \param min approximate minimum buffer size in frames (on return filled with actual minimum)
- * \param mindir Sub unit direction for minimum (on return filled with actual direction)
* \param max approximate maximum buffer size in frames (on return filled with actual maximum)
- * \param maxdir Sub unit direction for maximum (on return filled with actual direction)
* \return 0 otherwise a negative error code if configuration space would become empty
- *
- * Wanted/actual exact min/max is <,=,> val following dir (-1,0,1)
*/
int snd_pcm_hw_params_set_buffer_size_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_uframes_t *min, snd_pcm_uframes_t *max)
{
* \param params Configuration space
* \param val approximate target buffer size in frames / returned chosen approximate target buffer size in frames
* \return 0 otherwise a negative error code if configuration space is empty
- *
- * target/chosen exact value is <,=,> val following dir (-1,0,1)
*/
#ifndef DOXYGEN
int INTERNAL(snd_pcm_hw_params_set_buffer_size_near)(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_uframes_t *val)
* \param pcm PCM handle
* \param params Configuration space
* \param val approximate target tick duration in us / returned chosen approximate target tick duration in us
+ * \param dir Sub unit direction
* \return 0 otherwise a negative error code if configuration space is empty
*
* target/chosen exact value is <,=,> val following dir (-1,0,1)
/**
* \brief frees a previously allocated #snd_pcm_sw_params_t
- * \param pointer to object to free
+ * \param obj pointer to object to free
*/
void snd_pcm_sw_params_free(snd_pcm_sw_params_t *obj)
{
*dst = *src;
}
-/*
+/**
* \brief Get boundary for ring pointers from a software configuration container
* \param params Software configuration container
* \param val Returned boundary in frames
* \brief Get xfer align from a software configuration container
* \param params Software configuration container
* \param val returned chunk size (frames are attempted to be transferred in chunks)
- * \param 0 otherwise a negative error code
+ * \return 0 otherwise a negative error code
*/
#ifndef DOXYGEN
int INTERNAL(snd_pcm_sw_params_get_xfer_align)(const snd_pcm_sw_params_t *params, snd_pcm_uframes_t *val)
/**
* \brief frees a previously allocated #snd_pcm_status_t
- * \param pointer to object to free
+ * \param obj pointer to object to free
*/
void snd_pcm_status_free(snd_pcm_status_t *obj)
{
/**
* \brief Get state from a PCM status container (see #snd_pcm_state)
+ * \param obj #snd_pcm_status_t pointer
* \return PCM state
*/
snd_pcm_state_t snd_pcm_status_get_state(const snd_pcm_status_t *obj)
/**
* \brief Get trigger timestamp from a PCM status container
+ * \param obj #snd_pcm_status_t pointer
* \param ptr Pointer to returned timestamp
*/
void snd_pcm_status_get_trigger_tstamp(const snd_pcm_status_t *obj, snd_timestamp_t *ptr)
/**
* \brief Get trigger hi-res timestamp from a PCM status container
+ * \param obj #snd_pcm_status_t pointer
* \param ptr Pointer to returned timestamp
*/
#ifndef DOXYGEN
/**
* \brief Get "now" timestamp from a PCM status container
+ * \param obj #snd_pcm_status_t pointer
* \param ptr Pointer to returned timestamp
*/
void snd_pcm_status_get_tstamp(const snd_pcm_status_t *obj, snd_timestamp_t *ptr)
/**
* \brief Get "now" hi-res timestamp from a PCM status container
+ * \param obj pointer to #snd_pcm_status_t
* \param ptr Pointer to returned timestamp
*/
#ifndef DOXYGEN
/**
* \brief frees a previously allocated #snd_pcm_info_t
- * \param pointer to object to free
+ * \param obj pointer to object to free
*/
void snd_pcm_info_free(snd_pcm_info_t *obj)
{
* \brief Application has completed the access to area requested with #snd_pcm_mmap_begin
* \param pcm PCM handle
* \param offset area offset in area steps (== frames)
- * \param size area portion size in frames
+ * \param frames area portion size in frames
* \return count of transferred frames otherwise a negative error code
*
* You should pass this function the offset value that
-/**
- * \file pcm/pcm_direct.c
- * \ingroup PCM_Plugins
- * \brief PCM Direct Stream Mixing (dmix) Plugin Interface
- * \author Jaroslav Kysela <perex@suse.cz>
- * \date 2003
- */
/*
* PCM - Direct Stream Mixing
* Copyright (c) 2003 by Jaroslav Kysela <perex@suse.cz>
-/**
- * \file pcm/pcm_dmix.c
- * \ingroup PCM_Plugins
- * \brief PCM Direct Stream Mixing (dmix) Plugin Interface
- * \author Jaroslav Kysela <perex@suse.cz>
- * \date 2003
- */
/*
* PCM - Direct Stream Mixing
* Copyright (c) 2003 by Jaroslav Kysela <perex@suse.cz>
const char *_snd_module_pcm_dmix = "";
#endif
+#ifndef DOC_HIDDEN
/* start is pending - this state happens when rate plugin does a delayed commit */
#define STATE_RUN_PENDING 1024
+#endif
/*
*
* if no concurrent access is allowed in the mixing routines, we need to protect
* the area via semaphore
*/
+#ifndef DOC_HIDDEN
#ifdef NO_CONCURRENT_ACCESS
#define dmix_down_sem(dmix) snd_pcm_direct_semaphore_down(dmix, DIRECT_IPC_SEM_CLIENT)
#define dmix_up_sem(dmix) snd_pcm_direct_semaphore_up(dmix, DIRECT_IPC_SEM_CLIENT)
#define dmix_down_sem(dmix)
#define dmix_up_sem(dmix)
#endif
+#endif
/*
* synchronize shm ring buffer with hardware
const char *_snd_module_pcm_dshare = "";
#endif
+#ifndef DOC_HIDDEN
/* start is pending - this state happens when rate plugin does a delayed commit */
#define STATE_RUN_PENDING 1024
+#endif
static void do_silence(snd_pcm_t *pcm)
{
* \param pcmp Returns created PCM handle
* \param name Name of PCM
* \param ipc_key IPC key for semaphore and shared memory
- * \param ipc_mode IPC permissions for semaphore and shared memory
+ * \param ipc_perm IPC permissions for semaphore and shared memory
* \param params Parameters for slave
* \param bindings Channel bindings
* \param slowptr Slow but more precise pointer updates
* \param fname Filename (or NULL if file descriptor is available)
* \param fd File descriptor
* \param fmt File format ("raw" is supported only)
+ * \param perm File permission
* \param slave Slave PCM handle
* \param close_slave When set, the slave PCM handle is closed with copy PCM
* \retval zero on success otherwise a negative error code
((enum sndrv_pcm_state) (hw)->mmap_status->state)
#define FAST_PCM_TSTAMP(hw) \
((hw)->mmap_status->tstamp)
-#endif /* DOC_HIDDEN */
struct timespec snd_pcm_hw_fast_tstamp(snd_pcm_t *pcm)
{
res.tv_nsec *= 1000L;
return res;
}
+#endif /* DOC_HIDDEN */
static int sync_ptr1(snd_pcm_hw_t *hw, unsigned int flags)
{
* \param pcmp Returns created PCM handle
* \param name Name of PCM
* \param fd File descriptor
+ * \param mmap_emulation Boolean flag for mmap emulation mode
+ * \param sync_ptr_ioctl Boolean flag for sync_ptr ioctl
* \retval zero on success otherwise a negative error code
* \warning Using of this function might be dangerous in the sense
* of compatibility reasons. The prototype might be freely
return (int32_t)data;
}
+#ifndef DOC_HIDDEN
static void snd_pcm_iec958_decode(snd_pcm_iec958_t *iec,
const snd_pcm_channel_area_t *dst_areas,
snd_pcm_uframes_t dst_offset,
}
}
}
+#endif /* DOC_HIDDEN */
static int snd_pcm_iec958_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
{
* \param sformat Slave (destination) format
* \param slave Slave PCM handle
* \param close_slave When set, the slave PCM handle is closed with copy PCM
+ * \param status_bits The IEC958 status bits
+ * \param preamble_vals The preamble byte values
* \retval zero on success otherwise a negative error code
* \warning Using of this function might be dangerous in the sense
* of compatibility reasons. The prototype might be freely
* \brief Creates a new LADSPA<->ALSA Plugin
* \param pcmp Returns created PCM handle
* \param name Name of PCM
- * \param sformat Slave (destination) format
+ * \param ladspa_path The path for LADSPA plugins
+ * \param ladspa_pplugins The playback configuration
+ * \param ladspa_cplugins The capture configuration
* \param slave Slave PCM handle
* \param close_slave When set, the slave PCM handle is closed with copy PCM
* \retval zero on success otherwise a negative error code
/**
* \brief Set name of a #SND_PCM_TYPE_METER PCM scope
* \param scope PCM meter scope
- * \param name scope name
+ * \param val scope name
*/
void snd_pcm_scope_set_name(snd_pcm_scope_t *scope, const char *val)
{
/**
* \brief Add a s16 pseudo scope to a #SND_PCM_TYPE_METER PCM
+ * \param pcm The pcm handle
* \param name Scope name
* \param scopep Pointer to newly created and added scope
* \return 0 on success otherwise a negative error code
* \brief Silence a PCM samples buffer
* \param format Sample format
* \param data Buffer
- * \return samples Samples count
+ * \param samples Samples count
+ * \return 0 if successful or a negative error code
*/
int snd_pcm_format_set_silence(snd_pcm_format_t format, void *data, unsigned int samples)
{
* \param width Nominal bits per sample
* \param pwidth Physical bit width of the format
* \param unsignd Sign: 0 signed, 1 unsigned
- * \return big_endian Endian: 0 little endian, 1 big endian
+ * \param big_endian Endian: 0 little endian, 1 big endian
+ * \return The matching format type, or #SND_PCM_FORMAT_UNKNOWN if no match
*/
snd_pcm_format_t snd_pcm_build_linear_format(int width, int pwidth, int unsignd, int big_endian)
{
}
}
+#ifndef DOC_HIDDEN
typedef struct {
snd_pcm_access_t access;
snd_pcm_format_t format;
unsigned int channels;
unsigned int rate;
} snd_pcm_plug_params_t;
+#endif
static int snd_pcm_plug_change_rate(snd_pcm_t *pcm, snd_pcm_t **new, snd_pcm_plug_params_t *clt, snd_pcm_plug_params_t *slv)
{
return snd_pcm_hw_free(rate->gen.slave);
}
-int snd_pcm_rate_channel_info(snd_pcm_t *pcm, snd_pcm_channel_info_t * info)
+static int snd_pcm_rate_channel_info(snd_pcm_t *pcm, snd_pcm_channel_info_t * info)
{
return snd_pcm_channel_info_shm(pcm, info, -1);
}
return 0;
}
+/**
+ * \brief Set up a simple PCM
+ * \param pcm PCM handle
+ * \param rate Sample rate
+ * \param channels Number of channels
+ * \param format PCM format
+ * \param subformat PCM subformat
+ * \param latency Latency type
+ * \param access PCM acceess type
+ * \param xrun_type XRUN type
+ * \return 0 if successful, or a negative error code
+ *
+ * \warning The simple PCM API may be broken in the current release.
+ */
int snd_spcm_init(snd_pcm_t *pcm,
unsigned int rate,
unsigned int channels,
return 0;
}
+/**
+ * \brief Initialize simple PCMs in the duplex mode
+ * \param playback_pcm PCM handle for playback
+ * \param capture_pcm PCM handle for capture
+ * \param rate Sample rate
+ * \param channels Number of channels
+ * \param format PCM format
+ * \param subformat PCM subformat
+ * \param latency Latency type
+ * \param access PCM acceess type
+ * \param xrun_type XRUN type
+ * \param duplex_type Duplex mode
+ * \return 0 if successful, or a negative error code
+ *
+ * \warning The simple PCM API may be broken in the current release.
+ */
int snd_spcm_init_duplex(snd_pcm_t *playback_pcm,
snd_pcm_t *capture_pcm,
unsigned int rate,
return 0;
}
+/**
+ * \brief Get the set up of simple PCM
+ * \param pcm PCM handle
+ * \param rate Pointer to store the current sample rate
+ * \param buffer_size Pointer to store the current buffer size
+ * \param period_size Pointer to store the current period size
+ * \return 0 if successful, or a negative error code
+ *
+ * \warning The simple PCM API may be broken in the current release.
+ */
int snd_spcm_init_get_params(snd_pcm_t *pcm,
unsigned int *rate,
snd_pcm_uframes_t *buffer_size,
* TODO: use SIMD operations
*/
+#ifndef DOC_HIDDEN
#define CONVERT_AREA(TYPE) do { \
unsigned int ch, fr; \
TYPE *src, *dst; \
break; \
}
+#endif /* DOC_HIDDEN */
+
/* 2-channel stereo control */
static void softvol_convert_stereo_vol(snd_pcm_softvol_t *svol,
const snd_pcm_channel_area_t *dst_areas,
* \param pcmp Returns created PCM handle
* \param name Name of PCM
* \param sformat Slave format
- * \param card card index of the control
+ * \param ctl_card card index of the control
+ * \param ctl_id The control element
+ * \param cchannels PCM channels
* \param min_dB minimal dB value
* \param resolution resolution of control
* \param slave Slave PCM handle
/**
* \brief get returned events from poll descriptors
- * \param pcm rawmidi RawMidi handle
+ * \param rawmidi rawmidi RawMidi handle
* \param pfds array of poll descriptors
* \param nfds count of poll descriptors
* \param revents returned events
/**
* \brief allocate a new snd_rawmidi_info_t structure
- * \param ptr returned pointer
+ * \param info returned pointer
* \return 0 on success otherwise a negative error code if fails
*
* Allocates a new snd_rawmidi_params_t structure using the standard
/**
* \brief allocate the snd_rawmidi_params_t structure
- * \param ptr returned pointer
+ * \param params returned pointer
* \return 0 on success otherwise a negative error code if fails
*
* Allocates a new snd_rawmidi_params_t structure using the standard
#define SNDRV_FILE_RAWMIDI "/dev/snd/midiC%iD%i"
#define SNDRV_RAWMIDI_VERSION_MAX SNDRV_PROTOCOL_VERSION(2, 0, 0)
+#ifndef DOC_HIDDEN
typedef struct {
int open;
int fd;
int card, device, subdevice;
} snd_rawmidi_hw_t;
+#endif
static int snd_rawmidi_hw_close(snd_rawmidi_t *rmidi)
{
#endif
+#ifndef DOC_HIDDEN
typedef struct {
int open;
snd_seq_event_t out_event;
int pending;
} snd_rawmidi_virtual_t;
+#endif
static int snd_rawmidi_virtual_close(snd_rawmidi_t *rmidi)
{
The source and dest fields are source and destination addresses.
The data field is a union of event data.
-\subsction seq_ev_queue Scheduling queue
+\subsection seq_ev_queue Scheduling queue
An event can be delivered either on scheduled or direct dispatch mode.
On the scheduling mode, an event is once stored on the priority queue
* \brief Open the ALSA sequencer using local configuration
*
* \param seqp Pointer to a snd_seq_t pointer.
+ * \param name The name to open
* \param streams The read/write mode of the sequencer.
* \param mode Optional modifier
* \param lconf Local configuration
/**
* \brief Close the sequencer
- * \param handle Handle returned from #snd_seq_open()
+ * \param seq Handle returned from #snd_seq_open()
* \return 0 on success otherwise a negative error code
*
* Closes the sequencer client and releases its resources.
/**
* \brief Frees a previously allocated #snd_seq_system_info_t
- * \param pointer to object to free
+ * \param obj pointer to object to free
*/
void snd_seq_system_info_free(snd_seq_system_info_t *obj)
{
/**
* \brief frees a previously allocated #snd_seq_client_info_t
- * \param pointer to object to free
+ * \param obj pointer to object to free
*/
void snd_seq_client_info_free(snd_seq_client_info_t *obj)
{
/**
* \brief frees a previously allocated #snd_seq_port_info_t
- * \param pointer to object to free
+ * \param obj pointer to object to free
*/
void snd_seq_port_info_free(snd_seq_port_info_t *obj)
{
/**
* \brief Get the type bits of a port_info container
* \param info port_info container
- * \return port type bits
+ * \param type port type bits
*
* \sa snd_seq_get_port_info(), snd_seq_port_info_get_type()
*/
/**
* \brief frees a previously allocated #snd_seq_port_subscribe_t
- * \param pointer to object to free
+ * \param obj pointer to object to free
*/
void snd_seq_port_subscribe_free(snd_seq_port_subscribe_t *obj)
{
/**
* \brief Get sender address of a port_subscribe container
* \param info port_subscribe container
- * \param addr sender address
*
* \sa snd_seq_subscribe_port(), snd_seq_port_subscribe_set_sender()
*/
/**
* \brief Get destination address of a port_subscribe container
* \param info port_subscribe container
- * \param addr destination address
*
* \sa snd_seq_subscribe_port(), snd_seq_port_subscribe_set_dest()
*/
/**
* \brief frees a previously allocated #snd_seq_query_subscribe_t
- * \param pointer to object to free
+ * \param obj pointer to object to free
*/
void snd_seq_query_subscribe_free(snd_seq_query_subscribe_t *obj)
{
/**
* \brief frees a previously allocated #snd_seq_queue_info_t
- * \param pointer to object to free
+ * \param obj pointer to object to free
*/
void snd_seq_queue_info_free(snd_seq_queue_info_t *obj)
{
* \brief Get the queue usage flag to the client
* \param seq sequencer handle
* \param q queue id
- * \param client client id
* \return 1 = client is allowed to access the queue, 0 = not allowed,
* otherwise a negative error code
*
* \brief Set the queue usage flag to the client
* \param seq sequencer handle
* \param q queue id
- * \param client client id
* \param used non-zero if the client is allowed
* \return 0 on success otherwise a negative error code
*
/**
* \brief frees a previously allocated #snd_seq_queue_status_t
- * \param pointer to object to free
+ * \param obj pointer to object to free
*/
void snd_seq_queue_status_free(snd_seq_queue_status_t *obj)
{
/**
* \brief Get the real time of a queue_status container
* \param info queue_status container
- * \param time real time
*
* \sa snd_seq_get_queue_status()
*/
/**
* \brief frees a previously allocated #snd_seq_queue_tempo_t
- * \param pointer to object to free
+ * \param obj pointer to object to free
*/
void snd_seq_queue_tempo_free(snd_seq_queue_tempo_t *obj)
{
/**
* \brief frees a previously allocated #snd_seq_queue_timer_t
- * \param pointer to object to free
+ * \param obj pointer to object to free
*/
void snd_seq_queue_timer_free(snd_seq_queue_timer_t *obj)
{
/**
* \brief frees a previously allocated #snd_seq_remove_events_t
- * \param pointer to object to free
+ * \param obj pointer to object to free
*/
void snd_seq_remove_events_free(snd_seq_remove_events_t *obj)
{
/**
* \brief frees a previously allocated #snd_seq_client_pool_t
- * \param pointer to object to free
+ * \param obj pointer to object to free
*/
void snd_seq_client_pool_free(snd_seq_client_pool_t *obj)
{
/**
* \brief frees a previously allocated #snd_instr_header_t
- * \param pointer to object to free
+ * \param obj poitner to object to free
*/
void snd_instr_header_free(snd_instr_header_t *obj)
{
const char *_snd_module_seq_hw = "";
#endif
+#ifndef DOC_HIDDEN
#define SNDRV_FILE_SEQ "/dev/snd/seq"
#define SNDRV_FILE_ALOADSEQ "/dev/aloadSEQ"
#define SNDRV_SEQ_VERSION_MAX SNDRV_PROTOCOL_VERSION(1, 0, 1)
typedef struct {
int fd;
} snd_seq_hw_t;
+#endif /* DOC_HIDDEN */
static int snd_seq_hw_close(snd_seq_t *seq)
{
/*
* event list
*/
+#ifndef DOC_HIDDEN
static struct status_event_list_t {
int event;
int qlen;
{SND_SEQ_EVENT_REGPARAM, extra_decode_xrpn},
};
-#ifndef DOC_HIDDEN
#define numberof(ary) (sizeof(ary)/sizeof(ary[0]))
-#endif
+#endif /* DOC_HIDDEN */
/**
* \brief Initialize MIDI event parser
/**
* \brief Free MIDI event parser
- * \param rdev MIDI event parser
+ * \param dev MIDI event parser
* \return 0 on success otherwise a negative error code
*
* Frees MIDI event parser.
/**
* \brief simple subscription (w/o exclusive & time conversion)
+ * \param seq sequencer handle
* \param myport the port id as receiver
* \param src_client sender client id
* \param src_port sender port id
/**
* \brief simple subscription (w/o exclusive & time conversion)
+ * \param seq sequencer handle
* \param myport the port id as sender
* \param dest_client destination client id
* \param dest_port destination port id
/**
* \brief simple disconnection
+ * \param seq sequencer handle
* \param myport the port id as receiver
* \param src_client sender client id
* \param src_port sender port id
/**
* \brief simple disconnection
+ * \param seq sequencer handle
* \param myport the port id as sender
* \param dest_client destination client id
* \param dest_port destination port id
#include <sys/shm.h>
#include "list.h"
+#ifndef DOC_HIDDEN
struct snd_shm_area {
struct list_head list;
int shmid;
void *ptr;
int share;
};
+#endif
static LIST_HEAD(shm_areas);
+/**
+ * \brief Create a shm area record
+ * \param shmid IPC SHM ID
+ * \param ptr the shared area pointer
+ * \return The allocated shm area record, NULL if fail
+ *
+ * Allocates a shared area record with the given SHM ID and pointer.
+ * The record has a reference counter, which is initialized to 1 by this function.
+ */
struct snd_shm_area *snd_shm_area_create(int shmid, void *ptr)
-{
+p{
struct snd_shm_area *area = malloc(sizeof(*area));
if (area) {
area->shmid = shmid;
return area;
}
+/**
+ * \brief Increase the reference counter of shm area record
+ * \param area shm area record
+ * \return the shm area record (identical with the argument)
+ *
+ * Increases the reference counter of the given shared area record.
+ */
struct snd_shm_area *snd_shm_area_share(struct snd_shm_area *area)
{
if (area == NULL)
return area;
}
+/**
+ * \brief Release the shared area record
+ * \param area the shared are record
+ * \return 0 if successful, or a negative error code
+ *
+ * Decreases the reference counter of the given shared area record, and
+ * releases the resources automaticall if it reaches to 0.
+ */
int snd_shm_area_destroy(struct snd_shm_area *area)
{
if (area == NULL)
/**
* \brief allocate a new snd_timer_info_t structure
- * \param ptr returned pointer
+ * \param info returned pointer
* \return 0 on success otherwise a negative error code if fails
*
* Allocates a new snd_timer_info_t structure using the standard
/**
* \brief allocate a new snd_timer_params_t structure
- * \param ptr returned pointer
+ * \param params returned pointer
* \return 0 on success otherwise a negative error code if fails
*
* Allocates a new snd_timer_params_t structure using the standard
/**
* \brief set timer auto start
* \param params pointer to #snd_timer_params_t structure
+ * \param auto_start The boolean value to set
*/
int snd_timer_params_set_auto_start(snd_timer_params_t * params, int auto_start)
{
/**
* \brief set timer exclusive use
* \param params pointer to #snd_timer_params_t structure
+ * \param exclusive The boolean value to set
*/
#ifndef DOXYGEN
int INTERNAL(snd_timer_params_set_exclusive)(snd_timer_params_t * params, int exclusive)
/**
* \brief set timer early event
* \param params pointer to #snd_timer_params_t structure
+ * \param early_event The boolean value to set
*/
int snd_timer_params_set_early_event(snd_timer_params_t * params, int early_event)
{
/**
* \brief set timer ticks
* \param params pointer to #snd_timer_params_t structure
+ * \param ticks Ticks to set
*/
void snd_timer_params_set_ticks(snd_timer_params_t * params, long ticks)
{
/**
* \brief set timer queue size (32-1024)
* \param params pointer to #snd_timer_params_t structure
+ * \param queue_size The queue size to set
*/
void snd_timer_params_set_queue_size(snd_timer_params_t * params, long queue_size)
{
/**
* \brief set timer event filter
* \param params pointer to #snd_timer_params_t structure
+ * \param filter The event filter bits to set
*/
#ifndef DOXYGEN
void INTERNAL(snd_timer_params_set_filter)(snd_timer_params_t * params, unsigned int filter)
/**
* \brief allocate a new snd_timer_status_t structure
- * \param ptr returned pointer
+ * \param status returned pointer
* \return 0 on success otherwise a negative error code if fails
*
* Allocates a new snd_timer_status_t structure using the standard
#include <limits.h>
#include "local.h"
+#ifndef DOC_HIDDEN
typedef struct {
int (*close)(snd_timer_t *timer);
int (*nonblock)(snd_timer_t *timer, int nonblock);
struct list_head async_handlers;
};
-int snd_timer_hw_open(snd_timer_t **handle, const char *name, int dev_class, int dev_sclass, int card, int device, int subdevice, int mode);
-
typedef struct {
int (*close)(snd_timer_query_t *timer);
int (*next_device)(snd_timer_query_t *timer, snd_timer_id_t *tid);
snd_timer_query_ops_t *ops;
void *private_data;
};
+#endif /* DOC_HIDDEN */
+
+int snd_timer_hw_open(snd_timer_t **handle, const char *name, int dev_class, int dev_sclass, int card, int device, int subdevice, int mode);
int snd_timer_query_hw_open(snd_timer_query_t **handle, const char *name, int mode);
/**
* \brief allocate a new snd_timer_ginfo_t structure
- * \param ptr returned pointer
+ * \param info returned pointer
* \return 0 on success otherwise a negative error code if fails
*
* Allocates a new snd_timer_info_t structure using the standard
/**
* \brief set timer identification
* \param obj pointer to #snd_timer_ginfo_t structure
+ * \param tid pointer to #snd_timer_id_t structure
* \return zero on success otherwise a negative error number
*/
int snd_timer_ginfo_set_tid(snd_timer_ginfo_t *obj, snd_timer_id_t *tid)
/**
* \brief allocate a new snd_timer_id_t structure
- * \param ptr returned pointer
+ * \param info returned pointer
* \return 0 on success otherwise a negative error code if fails
*
* Allocates a new snd_timer_id_t structure using the standard
/**
* \brief get timer sub-class
- * \param params pointer to #snd_timer_id_t structure
+ * \param tid pointer to #snd_timer_id_t structure
* \return timer sub-class
*/
int snd_timer_id_get_sclass(snd_timer_id_t * tid)
/**
* \brief get timer card
- * \param params pointer to #snd_timer_id_t structure
+ * \param tid pointer to #snd_timer_id_t structure
* \return timer card number
*/
int snd_timer_id_get_card(snd_timer_id_t * tid)
/**
* \brief get timer device
- * \param params pointer to #snd_timer_id_t structure
+ * \param tid pointer to #snd_timer_id_t structure
* \return timer device number
*/
int snd_timer_id_get_device(snd_timer_id_t * tid)
/**
* \brief get timer subdevice
- * \param params pointer to #snd_timer_id_t structure
+ * \param tid pointer to #snd_timer_id_t structure
* \return timer subdevice number
*/
int snd_timer_id_get_subdevice(snd_timer_id_t * tid)
#include <wordexp.h>
#include <assert.h>
+/**
+ * \brief Get the full file name
+ * \param file The file name string to parse
+ * \param result The pointer to store the resultant file name
+ * \return 0 if successful, or a negative error code
+ *
+ * Parses the given file name with POSIX-Shell-like expansion and
+ * stores the first matchine one. The returned string is strdup'ed.
+ */
int snd_user_file(const char *file, char **result)
{
wordexp_t we;
git://git.alsa-project.org / alsa-lib.git / commitdiff