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

Corrections by Kevin Conder <kconder@interaccess.com>

Browse source
This commit is contained in:
Jaroslav Kysela 2002-03-12 20:14:33 +00:00
parent b559c97833
commit 853304bbf4
39 changed files with 386 additions and 386 deletions
Download patch file Download diff file Expand all files Collapse all files

12
include/asoundef.h
View file

@ -6,7 +6,7 @@
* \author Takashi Iwai <tiwai@suse.de>
* \date 1998-2001
*
* Definitions of constatns for the ALSA driver
* Definitions of constants for the ALSA driver
*
*
* This library is free software; you can redistribute it and/or modify
@ -33,7 +33,7 @@ extern "C" {
#endif
/**
* \defgroup Digital_Audio_Interface Contants For Digital Audio Interface
* \defgroup Digital_Audio_Interface Constants For Digital Audio Interface
* AES/IEC958 channel status bits
* \{
*/
@ -228,10 +228,10 @@ extern "C" {
#define MIDI_CTL_E5_PHASER_DEPTH 0x5f /**< E5 Phaser Depth */
#define MIDI_CTL_DATA_INCREMENT 0x60 /**< Data Increment */
#define MIDI_CTL_DATA_DECREMENT 0x61 /**< Data Decrement */
#define MIDI_CTL_NONREG_PARM_NUM_LSB 0x62 /**< Nonregister parameter number */
#define MIDI_CTL_NONREG_PARM_NUM_MSB 0x63 /**< Nonregister parameter number */
#define MIDI_CTL_REGIST_PARM_NUM_LSB 0x64 /**< Register parameter number */
#define MIDI_CTL_REGIST_PARM_NUM_MSB 0x65 /**< Register parameter number */
#define MIDI_CTL_NONREG_PARM_NUM_LSB 0x62 /**< Non-registered parameter number */
#define MIDI_CTL_NONREG_PARM_NUM_MSB 0x63 /**< Non-registered parameter number */
#define MIDI_CTL_REGIST_PARM_NUM_LSB 0x64 /**< Registered parameter number */
#define MIDI_CTL_REGIST_PARM_NUM_MSB 0x65 /**< Registered parameter number */
#define MIDI_CTL_ALL_SOUNDS_OFF 0x78 /**< All sounds off */
#define MIDI_CTL_RESET_CONTROLLERS 0x79 /**< Reset Controllers */
#define MIDI_CTL_LOCAL_CONTROL_SWITCH 0x7a /**< Local control switch */

8
include/control.h
View file

@ -53,10 +53,10 @@ typedef struct snd_aes_iec958 {
/** CTL card info container */
typedef struct _snd_ctl_card_info snd_ctl_card_info_t;
/** CTL element identificator container */
/** CTL element identifier container */
typedef struct _snd_ctl_elem_id snd_ctl_elem_id_t;
/** CTL element identificator list container */
/** CTL element identifier list container */
typedef struct _snd_ctl_elem_list snd_ctl_elem_list_t;
/** CTL element info container */
@ -396,9 +396,9 @@ void snd_ctl_elem_value_get_iec958(const snd_ctl_elem_value_t *obj, snd_aes_iec9
void snd_ctl_elem_value_set_iec958(snd_ctl_elem_value_t *obj, const snd_aes_iec958_t *ptr);
/**
* \defgroup HControl Highlevel Control Interface
* \defgroup HControl High level Control Interface
* \ingroup Control
* The highlevel control interface.
* The high level control interface.
* See \ref hcontrol page for more details.
* \{
*/

8
include/iatomic.h
View file

@ -1040,7 +1040,7 @@ static __inline__ void atomic_clear_mask(unsigned long mask, unsigned long *addr
/*
* non supported architecture.
*/
#warning "Atomic operations are not supported on this archictecture."
#warning "Atomic operations are not supported on this architecture."
typedef struct { volatile int counter; } atomic_t;
@ -1066,17 +1066,17 @@ typedef struct { volatile int counter; } atomic_t;
* Copyright (c) 2001 by Abramo Bagnara <abramo@alsa-project.org>
*/
/* Max number of times we must spin on a spinlock calling sched_yield().
/* Max number of times we must spin on a spin-lock calling sched_yield().
After MAX_SPIN_COUNT iterations, we put the calling thread to sleep. */
#ifndef MAX_SPIN_COUNT
#define MAX_SPIN_COUNT 50
#endif
/* Duration of sleep (in nanoseconds) when we can't acquire a spinlock
/* Duration of sleep (in nanoseconds) when we can't acquire a spin-lock
after MAX_SPIN_COUNT iterations of sched_yield().
This MUST BE > 2ms.
(Otherwise the kernel does busy-waiting for realtime threads,
(Otherwise the kernel does busy-waiting for real-time threads,
giving other threads no chance to run.) */
#ifndef SPIN_SLEEP_DURATION

4
include/mixer.h
View file

@ -118,7 +118,7 @@ snd_mixer_elem_type_t snd_mixer_elem_get_type(const snd_mixer_elem_t *obj);
/* Simple (legacy) mixer elements API */
/** Mixer simple element channel identificator */
/** Mixer simple element channel identifier */
typedef enum _snd_mixer_selem_channel_id {
/** Unknown */
SND_MIXER_SCHN_UNKNOWN = -1,
@ -139,7 +139,7 @@ typedef enum _snd_mixer_selem_channel_id {
SND_MIXER_SCHN_MONO = SND_MIXER_SCHN_FRONT_LEFT
} snd_mixer_selem_channel_id_t;
/** Mixer simple element identificator */
/** Mixer simple element identifier */
typedef struct _snd_mixer_selem_id snd_mixer_selem_id_t;
const char *snd_mixer_selem_channel_name(snd_mixer_selem_channel_id_t channel);

2
include/pcm.h
View file

@ -938,7 +938,7 @@ int16_t *snd_pcm_scope_s16_get_channel_buffer(snd_pcm_scope_t *scope,
* \{
*/
/* Deprecated functions, for compatibity */
/* Deprecated functions, for compatibility */
const char *snd_pcm_start_mode_name(snd_pcm_start_t mode);
const char *snd_pcm_xrun_mode_name(snd_pcm_xrun_t mode);
int snd_pcm_sw_params_set_start_mode(snd_pcm_t *pcm, snd_pcm_sw_params_t *params, snd_pcm_start_t val);

2
include/search.h
View file

@ -79,7 +79,7 @@ struct _ENTRY;
/* Family of hash table handling functions. The functions also
have reentrant counterparts ending with _r. The non-reentrant
functions all work on a signle internal hashing table. */
functions all work on a single internal hashing table. */
/* Search for entry matching ITEM.key in internal hash table. If
ACTION is `FIND' return found entry or signal error by returning

6
include/seq.h
View file

@ -81,7 +81,7 @@ typedef enum _snd_seq_type {
/** known client numbers */
#define SND_SEQ_CLIENT_SYSTEM 0 /**< system client */
#define SND_SEQ_CLIENT_DUMMY 62 /**< dummy ports */
#define SND_SEQ_CLIENT_OSS 63 /**< oss sequencer emulator */
#define SND_SEQ_CLIENT_OSS 63 /**< OSS sequencer emulator */
/*
*/
@ -211,7 +211,7 @@ typedef struct _snd_seq_port_info snd_seq_port_info_t;
/** known port numbers */
#define SND_SEQ_PORT_SYSTEM_TIMER 0 /**< system timer port */
#define SND_SEQ_PORT_SYSTEM_ANNOUNCE 1 /**< sysem announce port */
#define SND_SEQ_PORT_SYSTEM_ANNOUNCE 1 /**< system announce port */
/** port capabilities (32 bits) */
#define SND_SEQ_PORT_CAP_READ (1<<0) /**< readable from this port */
@ -550,7 +550,7 @@ int snd_seq_remove_events(snd_seq_t *handle, snd_seq_remove_events_t *info);
/**
* \defgroup SeqMisc Sequencer Miscellaneous
* Sequencer Mescellaneous
* Sequencer Miscellaneous
* \ingroup Sequencer
* \{
*/

2
include/seq_event.h
View file

@ -90,7 +90,7 @@ enum snd_seq_event_type {
SND_SEQ_EVENT_STOP,
/** Set tick queue position; event data type = #snd_seq_ev_queue_control_t */
SND_SEQ_EVENT_SETPOS_TICK,
/** Set realtime queue position; event data type = #snd_seq_ev_queue_control_t */
/** Set real-time queue position; event data type = #snd_seq_ev_queue_control_t */
SND_SEQ_EVENT_SETPOS_TIME,
/** (SMF) Tempo event; event data type = #snd_seq_ev_queue_control_t */
SND_SEQ_EVENT_TEMPO,

16
include/seqmid.h
View file

@ -91,7 +91,7 @@ extern "C" {
* \param ev event instance
* \param q queue id to schedule
* \param relative relative time-stamp if non-zero
* \param ttick tick time-stap to be delivered
* \param ttick tick time-stamp to be delivered
*/
#define snd_seq_ev_schedule_tick(ev, q, relative, ttick) \
((ev)->flags &= ~(SND_SEQ_TIME_STAMP_MASK | SND_SEQ_TIME_MODE_MASK),\
@ -177,7 +177,7 @@ extern "C" {
/**
* \brief set the start queue event
* \param ev event record
* \param q queud id to start
* \param q queue id to start
*/
#define snd_seq_ev_set_queue_start(ev, q) \
snd_seq_ev_set_queue_control(ev, SND_SEQ_EVENT_START, q, 0)
@ -185,7 +185,7 @@ extern "C" {
/**
* \brief set the stop queue event
* \param ev event record
* \param q queud id to stop
* \param q queue id to stop
*/
#define snd_seq_ev_set_queue_stop(ev, q) \
snd_seq_ev_set_queue_control(ev, SND_SEQ_EVENT_STOP, q, 0)
@ -193,7 +193,7 @@ extern "C" {
/**
* \brief set the stop queue event
* \param ev event record
* \param q queud id to continue
* \param q queue id to continue
*/
#define snd_seq_ev_set_queue_continue(ev, q) \
snd_seq_ev_set_queue_control(ev, SND_SEQ_EVENT_CONTINUE, q, 0)
@ -201,7 +201,7 @@ extern "C" {
/**
* \brief set the stop queue event
* \param ev event record
* \param q queud id to change tempo
* \param q queue id to change tempo
* \param val the new tempo value
*/
#define snd_seq_ev_set_queue_tempo(ev, q, val) \
@ -210,7 +210,7 @@ extern "C" {
/**
* \brief set the real-time position of a queue
* \param ev event record
* \param q queud id to change tempo
* \param q queue id to change tempo
* \param rtime the new real-time pointer
*/
#define snd_seq_ev_set_queue_pos_real(ev, q, rtime) \
@ -222,7 +222,7 @@ extern "C" {
/**
* \brief set the tick-time position of a queue
* \param ev event record
* \param q queud id to change tempo
* \param q queue id to change tempo
* \param ttime the new tick-time
*/
#define snd_seq_ev_set_queue_pos_tick(ev, q, ttime) \
@ -392,7 +392,7 @@ int snd_seq_reset_pool_input(snd_seq_t *seq);
(ev)->data.control.value = (val))
/**
* \brief set pitchbend event
* \brief set pitch-bend event
* \param ev event record
* \param ch channel number
* \param val pitch bend; zero centered from -8192 to 8191

2
include/timer.h
View file

@ -81,7 +81,7 @@ typedef enum _snd_timer_slave_class {
/** global timer - RTC */
#define SND_TIMER_GLOBAL_RTC 1
/** timer open mode flag - nonblocking behaviour */
/** timer open mode flag - non-blocking behaviour */
#define SND_TIMER_OPEN_NONBLOCK 0x0001
/** timer handle type */

4
src/compat/hsearch_r.c
View file

@ -156,7 +156,7 @@ hsearch_r (item, action, retval, htab)
hval += item.key[count];
}
/* First hash function: simply take the modul but prevent zero. */
/* First hash function: simply take the modulo but prevent zero. */
hval %= htab->size;
if (hval == 0)
++hval;
@ -185,7 +185,7 @@ hsearch_r (item, action, retval, htab)
do
{
/* Because SIZE is prime this guarantees to step through all
available indeces. */
available indexes. */
if (idx <= hval2)
idx = htab->size + idx - hval2;
else

18
src/conf.c
View file

@ -66,7 +66,7 @@ b
The ASCII characters representing whitespace can occur within literal
strings, int which case they are protected from the normal parsing process
(tey remain as part of the string). For example:
(they remain as part of the string). For example:
\code
name "John Smith"
@ -129,7 +129,7 @@ a {
\subsection conf_brackets Brackets
Open and close brackets indicate single array definition. The identificators
Open and close brackets indicate single array definition. The identifiers
are automatically generated starting with zero.
\code
@ -310,9 +310,9 @@ and default value is specified in the compound:
}
\endcode
\section confarg_refer Refering argument
\section confarg_refer Referring argument
Arguments are refered by dollar-sign ($) and name of argument:
Arguments are referred by dollar-sign ($) and name of argument:
\code
card $CARD
@ -361,7 +361,7 @@ pcm.demo {
<P>The ALSA library accepts the runtime modification of configuration.
The several build-in functions are available.</P>
<P>The function is refered using id @func and function name. All other
<P>The function is referred using id @func and function name. All other
values in the current compound are used as configuration for the function.
If compound func.<function_name> is defined in the root leafs, then library
and function from this compound configuration is used, otherwise the prefix
@ -404,8 +404,8 @@ compound node.</P>
<LI>The function load - snd_config_hook_load() - loads and parses the given
configuration files.
<LI>The function load_for_all_cards - snd_config_hook_load_for_all_cards() -
loads and parses the given configuration files for all installed soundcards.
The driver name (type of soundcard) is passed in the private configuration
loads and parses the given configuration files for all installed sound-cards.
The driver name (type of sound-card) is passed in the private configuration
node.
</UL>
@ -2537,11 +2537,11 @@ int snd_config_hook_load(snd_config_t *root, snd_config_t *config, snd_config_t
}
}
if ((err = snd_config_search(config, "files", &n)) < 0) {
SNDERR("Unable to find field files in the preload section");
SNDERR("Unable to find field files in the pre-load section");
return -EINVAL;
}
if ((err = snd_config_expand(n, root, NULL, private_data, &n)) < 0) {
SNDERR("Unable to expand filenames in the preload section");
SNDERR("Unable to expand filenames in the pre-load section");
return err;
}
if (snd_config_get_type(n) != SND_CONFIG_TYPE_COMPOUND) {

2
src/conf/alsa.conf
View file

@ -2,7 +2,7 @@
# ALSA library configuration file
#
# preload configuration files
# pre-load the configuration files
@hooks [
{

8
src/confmisc.c
View file

@ -45,8 +45,8 @@
strings. The result is string.
<LI>The datadir function - snd_func_datadir() - returns the
data directory. The result is string.
<LI>The refer function - snd_func_refer() - copies the refered
configuration. The result is same as the refered node.
<LI>The refer function - snd_func_refer() - copies the referred
configuration. The result is same as the referred node.
<LI>The card_driver function - snd_func_card_driver() - returns
the driver identification. The result is string.
<LI>The card_id function - snd_func_card_id() - returns
@ -881,8 +881,8 @@ SND_DLSYM_BUILD_VERSION(snd_func_private_pcm_subdevice, SND_CONFIG_DLSYM_VERSION
#endif
/**
* \brief Copy the refered configuration node
* \param dst The destination node (result type is same as refered node)
* \brief Copy the referred configuration node
* \param dst The destination node (result type is same as referred node)
* \param root The root source node (can be modified!!!)
* \param src The source node
* \param private_data The private_data node

2
src/control/cards.c
View file

@ -97,7 +97,7 @@ int snd_card_next(int *rcard)
* \return zero if success, otherwise a negative error code
*
* The accepted format is an integer value in ASCII representation
* or the card identifier (snd_id parameter for soundcard drivers).
* or the card identifier (snd_id parameter for sound-card drivers).
*/
int snd_card_get_index(const char *string)
{

258
src/control/control.c
View file

@ -226,9 +226,9 @@ int snd_ctl_card_info(snd_ctl_t *ctl, snd_ctl_card_info_t *info)
}
/**
* \brief Get a list of element identificators
* \brief Get a list of element identifiers
* \param ctl CTL handle
* \param list CTL element identificators list pointer
* \param list CTL element identifiers list pointer
* \return 0 on success otherwise a negative error code
*/
int snd_ctl_elem_list(snd_ctl_t *ctl, snd_ctl_elem_list_t *list)
@ -717,8 +717,8 @@ const char *snd_ctl_event_type_name(snd_ctl_event_type_t type)
}
/**
* \brief allocate space for CTL element identificators list
* \param obj CTL element identificators list
* \brief allocate space for CTL element identifiers list
* \param obj CTL element identifiers list
* \param entries Entries to allocate
* \return 0 on success otherwise a negative error code
*/
@ -736,8 +736,8 @@ int snd_ctl_elem_list_alloc_space(snd_ctl_elem_list_t *obj, unsigned int entries
}
/**
* \brief free previously allocated space for CTL element identificators list
* \param obj CTL element identificators list
* \brief free previously allocated space for CTL element identifiers list
* \param obj CTL element identifiers list
*/
void snd_ctl_elem_list_free_space(snd_ctl_elem_list_t *obj)
{
@ -758,9 +758,9 @@ unsigned int snd_ctl_event_elem_get_mask(const snd_ctl_event_t *obj)
}
/**
* \brief Get CTL element identificator for an element related event
* \brief Get CTL element identifier for an element related event
* \param obj CTL event
* \param ptr Pointer to returned CTL element identificator
* \param ptr Pointer to returned CTL element identifier
*/
void snd_ctl_event_elem_get_id(const snd_ctl_event_t *obj, snd_ctl_elem_id_t *ptr)
{
@ -770,9 +770,9 @@ void snd_ctl_event_elem_get_id(const snd_ctl_event_t *obj, snd_ctl_elem_id_t *pt
}
/**
* \brief Get element numeric identificator for an element related event
* \brief Get element numeric identifier for an element related event
* \param obj CTL event
* \return element numeric identificator
* \return element numeric identifier
*/
unsigned int snd_ctl_event_elem_get_numid(const snd_ctl_event_t *obj)
{
@ -782,9 +782,9 @@ unsigned int snd_ctl_event_elem_get_numid(const snd_ctl_event_t *obj)
}
/**
* \brief Get interface part of CTL element identificator for an element related event
* \brief Get interface part of CTL element identifier for an element related event
* \param obj CTL event
* \return interface part of element identificator
* \return interface part of element identifier
*/
snd_ctl_elem_iface_t snd_ctl_event_elem_get_interface(const snd_ctl_event_t *obj)
{
@ -794,9 +794,9 @@ snd_ctl_elem_iface_t snd_ctl_event_elem_get_interface(const snd_ctl_event_t *obj
}
/**
* \brief Get device part of CTL element identificator for an element related event
* \brief Get device part of CTL element identifier for an element related event
* \param obj CTL event
* \return device part of element identificator
* \return device part of element identifier
*/
unsigned int snd_ctl_event_elem_get_device(const snd_ctl_event_t *obj)
{
@ -806,9 +806,9 @@ unsigned int snd_ctl_event_elem_get_device(const snd_ctl_event_t *obj)
}
/**
* \brief Get subdevice part of CTL element identificator for an element related event
* \brief Get subdevice part of CTL element identifier for an element related event
* \param obj CTL event
* \return subdevice part of element identificator
* \return subdevice part of element identifier
*/
unsigned int snd_ctl_event_elem_get_subdevice(const snd_ctl_event_t *obj)
{
@ -818,9 +818,9 @@ unsigned int snd_ctl_event_elem_get_subdevice(const snd_ctl_event_t *obj)
}
/**
* \brief Get name part of CTL element identificator for an element related event
* \brief Get name part of CTL element identifier for an element related event
* \param obj CTL event
* \return name part of element identificator
* \return name part of element identifier
*/
const char *snd_ctl_event_elem_get_name(const snd_ctl_event_t *obj)
{
@ -830,9 +830,9 @@ const char *snd_ctl_event_elem_get_name(const snd_ctl_event_t *obj)
}
/**
* \brief Get index part of CTL element identificator for an element related event
* \brief Get index part of CTL element identifier for an element related event
* \param obj CTL event
* \return index part of element identificator
* \return index part of element identifier
*/
unsigned int snd_ctl_event_elem_get_index(const snd_ctl_event_t *obj)
{
@ -902,9 +902,9 @@ void snd_ctl_elem_id_copy(snd_ctl_elem_id_t *dst, const snd_ctl_elem_id_t *src)
}
/**
* \brief Get numeric identificator from a CTL element identificator
* \param obj CTL element identificator
* \return CTL element numeric identificator
* \brief Get numeric identifier from a CTL element identifier
* \param obj CTL element identifier
* \return CTL element numeric identifier
*/
unsigned int snd_ctl_elem_id_get_numid(const snd_ctl_elem_id_t *obj)
{
@ -913,8 +913,8 @@ unsigned int snd_ctl_elem_id_get_numid(const snd_ctl_elem_id_t *obj)
}
/**
* \brief Get interface part of a CTL element identificator
* \param obj CTL element identificator
* \brief Get interface part of a CTL element identifier
* \param obj CTL element identifier
* \return CTL element related interface
*/
snd_ctl_elem_iface_t snd_ctl_elem_id_get_interface(const snd_ctl_elem_id_t *obj)
@ -924,8 +924,8 @@ snd_ctl_elem_iface_t snd_ctl_elem_id_get_interface(const snd_ctl_elem_id_t *obj)
}
/**
* \brief Get device part of a CTL element identificator
* \param obj CTL element identificator
* \brief Get device part of a CTL element identifier
* \param obj CTL element identifier
* \return CTL element related device
*/
unsigned int snd_ctl_elem_id_get_device(const snd_ctl_elem_id_t *obj)
@ -935,8 +935,8 @@ unsigned int snd_ctl_elem_id_get_device(const snd_ctl_elem_id_t *obj)
}
/**
* \brief Get subdevice part of a CTL element identificator
* \param obj CTL element identificator
* \brief Get subdevice part of a CTL element identifier
* \param obj CTL element identifier
* \return CTL element related subdevice
*/
unsigned int snd_ctl_elem_id_get_subdevice(const snd_ctl_elem_id_t *obj)
@ -946,8 +946,8 @@ unsigned int snd_ctl_elem_id_get_subdevice(const snd_ctl_elem_id_t *obj)
}
/**
* \brief Get name part of a CTL element identificator
* \param obj CTL element identificator
* \brief Get name part of a CTL element identifier
* \param obj CTL element identifier
* \return CTL element name
*/
const char *snd_ctl_elem_id_get_name(const snd_ctl_elem_id_t *obj)
@ -957,8 +957,8 @@ const char *snd_ctl_elem_id_get_name(const snd_ctl_elem_id_t *obj)
}
/**
* \brief Get index part of a CTL element identificator
* \param obj CTL element identificator
* \brief Get index part of a CTL element identifier
* \param obj CTL element identifier
* \return CTL element index
*/
unsigned int snd_ctl_elem_id_get_index(const snd_ctl_elem_id_t *obj)
@ -968,9 +968,9 @@ unsigned int snd_ctl_elem_id_get_index(const snd_ctl_elem_id_t *obj)
}
/**
* \brief Set numeric identificator for a CTL element identificator
* \param obj CTL element identificator
* \param val CTL element numeric identificator
* \brief Set numeric identifier for a CTL element identifier
* \param obj CTL element identifier
* \param val CTL element numeric identifier
*/
void snd_ctl_elem_id_set_numid(snd_ctl_elem_id_t *obj, unsigned int val)
{
@ -979,8 +979,8 @@ void snd_ctl_elem_id_set_numid(snd_ctl_elem_id_t *obj, unsigned int val)
}
/**
* \brief Set interface part for a CTL element identificator
* \param obj CTL element identificator
* \brief Set interface part for a CTL element identifier
* \param obj CTL element identifier
* \param val CTL element related interface
*/
void snd_ctl_elem_id_set_interface(snd_ctl_elem_id_t *obj, snd_ctl_elem_iface_t val)
@ -990,8 +990,8 @@ void snd_ctl_elem_id_set_interface(snd_ctl_elem_id_t *obj, snd_ctl_elem_iface_t
}
/**
* \brief Set device part for a CTL element identificator
* \param obj CTL element identificator
* \brief Set device part for a CTL element identifier
* \param obj CTL element identifier
* \param val CTL element related device
*/
void snd_ctl_elem_id_set_device(snd_ctl_elem_id_t *obj, unsigned int val)
@ -1001,8 +1001,8 @@ void snd_ctl_elem_id_set_device(snd_ctl_elem_id_t *obj, unsigned int val)
}
/**
* \brief Set subdevice part for a CTL element identificator
* \param obj CTL element identificator
* \brief Set subdevice part for a CTL element identifier
* \param obj CTL element identifier
* \param val CTL element related subdevice
*/
void snd_ctl_elem_id_set_subdevice(snd_ctl_elem_id_t *obj, unsigned int val)
@ -1012,8 +1012,8 @@ void snd_ctl_elem_id_set_subdevice(snd_ctl_elem_id_t *obj, unsigned int val)
}
/**
* \brief Set name part for a CTL element identificator
* \param obj CTL element identificator
* \brief Set name part for a CTL element identifier
* \param obj CTL element identifier
* \param val CTL element name
*/
void snd_ctl_elem_id_set_name(snd_ctl_elem_id_t *obj, const char *val)
@ -1023,8 +1023,8 @@ void snd_ctl_elem_id_set_name(snd_ctl_elem_id_t *obj, const char *val)
}
/**
* \brief Set index part for a CTL element identificator
* \param obj CTL element identificator
* \brief Set index part for a CTL element identifier
* \param obj CTL element identifier
* \param val CTL element index
*/
void snd_ctl_elem_id_set_index(snd_ctl_elem_id_t *obj, unsigned int val)
@ -1097,9 +1097,9 @@ int snd_ctl_card_info_get_card(const snd_ctl_card_info_t *obj)
}
/**
* \brief Get card identificator from a CTL card info
* \brief Get card identifier from a CTL card info
* \param obj CTL card info
* \return card identificator
* \return card identifier
*/
const char *snd_ctl_card_info_get_id(const snd_ctl_card_info_t *obj)
{
@ -1154,7 +1154,7 @@ const char *snd_ctl_card_info_get_mixername(const snd_ctl_card_info_t *obj)
/**
* \brief Get card component list from a CTL card info
* \param obj CTL card info
* \return card mixer identificator
* \return card mixer identifier
*/
const char *snd_ctl_card_info_get_components(const snd_ctl_card_info_t *obj)
{
@ -1278,8 +1278,8 @@ void snd_ctl_elem_list_copy(snd_ctl_elem_list_t *dst, const snd_ctl_elem_list_t
}
/**
* \brief Set index of first wanted CTL element identificator in a CTL element identificators list
* \param obj CTL element identificators list
* \brief Set index of first wanted CTL element identifier in a CTL element identifiers list
* \param obj CTL element identifiers list
* \param val index of CTL element to put at position 0 of list
*/
void snd_ctl_elem_list_set_offset(snd_ctl_elem_list_t *obj, unsigned int val)
@ -1289,8 +1289,8 @@ void snd_ctl_elem_list_set_offset(snd_ctl_elem_list_t *obj, unsigned int val)
}
/**
* \brief Get number of used entries in CTL element identificators list
* \param obj CTL element identificator list
* \brief Get number of used entries in CTL element identifiers list
* \param obj CTL element identifier list
* \return number of used entries
*/
unsigned int snd_ctl_elem_list_get_used(const snd_ctl_elem_list_t *obj)
@ -1300,8 +1300,8 @@ unsigned int snd_ctl_elem_list_get_used(const snd_ctl_elem_list_t *obj)
}
/**
* \brief Get total count of elements present in CTL device (information present in every filled CTL element identificators list)
* \param obj CTL element identificator list
* \brief Get total count of elements present in CTL device (information present in every filled CTL element identifiers list)
* \param obj CTL element identifier list
* \return total number of elements
*/
unsigned int snd_ctl_elem_list_get_count(const snd_ctl_elem_list_t *obj)
@ -1311,10 +1311,10 @@ unsigned int snd_ctl_elem_list_get_count(const snd_ctl_elem_list_t *obj)
}
/**
* \brief Get CTL element identificator for an entry of a CTL element identificators list
* \param obj CTL element identificator list
* \brief Get CTL element identifier for an entry of a CTL element identifiers list
* \param obj CTL element identifier list
* \param idx Index of entry
* \param ptr Pointer to returned CTL element identificator
* \param ptr Pointer to returned CTL element identifier
*/
void snd_ctl_elem_list_get_id(const snd_ctl_elem_list_t *obj, unsigned int idx, snd_ctl_elem_id_t *ptr)
{
@ -1324,10 +1324,10 @@ void snd_ctl_elem_list_get_id(const snd_ctl_elem_list_t *obj, unsigned int idx,
}
/**
* \brief Get CTL element numeric identificator for an entry of a CTL element identificators list
* \param obj CTL element identificator list
* \brief Get CTL element numeric identifier for an entry of a CTL element identifiers list
* \param obj CTL element identifier list
* \param idx Index of entry
* \return CTL element numeric identificator
* \return CTL element numeric identifier
*/
unsigned int snd_ctl_elem_list_get_numid(const snd_ctl_elem_list_t *obj, unsigned int idx)
{
@ -1337,8 +1337,8 @@ unsigned int snd_ctl_elem_list_get_numid(const snd_ctl_elem_list_t *obj, unsigne
}
/**
* \brief Get interface part of CTL element identificator for an entry of a CTL element identificators list
* \param obj CTL element identificator list
* \brief Get interface part of CTL element identifier for an entry of a CTL element identifiers list
* \param obj CTL element identifier list
* \param idx Index of entry
* \return CTL element related interface
*/
@ -1350,8 +1350,8 @@ snd_ctl_elem_iface_t snd_ctl_elem_list_get_interface(const snd_ctl_elem_list_t *
}
/**
* \brief Get device part of CTL element identificator for an entry of a CTL element identificators list
* \param obj CTL element identificator list
* \brief Get device part of CTL element identifier for an entry of a CTL element identifiers list
* \param obj CTL element identifier list
* \param idx Index of entry
* \return CTL element related device
*/
@ -1363,8 +1363,8 @@ unsigned int snd_ctl_elem_list_get_device(const snd_ctl_elem_list_t *obj, unsign
}
/**
* \brief Get subdevice part of CTL element identificator for an entry of a CTL element identificators list
* \param obj CTL element identificator list
* \brief Get subdevice part of CTL element identifier for an entry of a CTL element identifiers list
* \param obj CTL element identifier list
* \param idx Index of entry
* \return CTL element related subdevice
*/
@ -1376,8 +1376,8 @@ unsigned int snd_ctl_elem_list_get_subdevice(const snd_ctl_elem_list_t *obj, uns
}
/**
* \brief Get name part of CTL element identificator for an entry of a CTL element identificators list
* \param obj CTL element identificator list
* \brief Get name part of CTL element identifier for an entry of a CTL element identifiers list
* \param obj CTL element identifier list
* \param idx Index of entry
* \return CTL element name
*/
@ -1389,8 +1389,8 @@ const char *snd_ctl_elem_list_get_name(const snd_ctl_elem_list_t *obj, unsigned
}
/**
* \brief Get index part of CTL element identificator for an entry of a CTL element identificators list
* \param obj CTL element identificator list
* \brief Get index part of CTL element identifier for an entry of a CTL element identifiers list
* \param obj CTL element identifier list
* \param idx Index of entry
* \return CTL element index
*/
@ -1467,7 +1467,7 @@ snd_ctl_elem_type_t snd_ctl_elem_info_get_type(const snd_ctl_elem_info_t *obj)
/**
* \brief Get info about readability from a CTL element id/info
* \param obj CTL element id/info
* \return 0 if element is not redable, 1 if element is readable
* \return 0 if element is not readable, 1 if element is readable
*/
int snd_ctl_elem_info_is_readable(const snd_ctl_elem_info_t *obj)
{
@ -1625,7 +1625,7 @@ void snd_ctl_elem_info_set_item(snd_ctl_elem_info_t *obj, unsigned int val)
/**
* \brief Get name for selected item in a #SND_CTL_ELEM_TYPE_ENUMERATED CTL element id/info
* \param obj CTL element id/info
* \return name of choosen item
* \return name of chosen item
*/
const char *snd_ctl_elem_info_get_item_name(const snd_ctl_elem_info_t *obj)
{
@ -1635,9 +1635,9 @@ const char *snd_ctl_elem_info_get_item_name(const snd_ctl_elem_info_t *obj)
}
/**
* \brief Get CTL element identificator of a CTL element id/info
* \brief Get CTL element identifier of a CTL element id/info
* \param obj CTL element id/info
* \param ptr Pointer to returned CTL element identificator
* \param ptr Pointer to returned CTL element identifier
*/
void snd_ctl_elem_info_get_id(const snd_ctl_elem_info_t *obj, snd_ctl_elem_id_t *ptr)
{
@ -1646,9 +1646,9 @@ void snd_ctl_elem_info_get_id(const snd_ctl_elem_info_t *obj, snd_ctl_elem_id_t
}
/**
* \brief Get element numeric identificator of a CTL element id/info
* \brief Get element numeric identifier of a CTL element id/info
* \param obj CTL element id/info
* \return element numeric identificator
* \return element numeric identifier
*/
unsigned int snd_ctl_elem_info_get_numid(const snd_ctl_elem_info_t *obj)
{
@ -1657,9 +1657,9 @@ unsigned int snd_ctl_elem_info_get_numid(const snd_ctl_elem_info_t *obj)
}
/**
* \brief Get interface part of CTL element identificator of a CTL element id/info
* \brief Get interface part of CTL element identifier of a CTL element id/info
* \param obj CTL element id/info
* \return interface part of element identificator
* \return interface part of element identifier
*/
snd_ctl_elem_iface_t snd_ctl_elem_info_get_interface(const snd_ctl_elem_info_t *obj)
{
@ -1668,9 +1668,9 @@ snd_ctl_elem_iface_t snd_ctl_elem_info_get_interface(const snd_ctl_elem_info_t *
}
/**
* \brief Get device part of CTL element identificator of a CTL element id/info
* \brief Get device part of CTL element identifier of a CTL element id/info
* \param obj CTL element id/info
* \return device part of element identificator
* \return device part of element identifier
*/
unsigned int snd_ctl_elem_info_get_device(const snd_ctl_elem_info_t *obj)
{
@ -1679,9 +1679,9 @@ unsigned int snd_ctl_elem_info_get_device(const snd_ctl_elem_info_t *obj)
}
/**
* \brief Get subdevice part of CTL element identificator of a CTL element id/info
* \brief Get subdevice part of CTL element identifier of a CTL element id/info
* \param obj CTL element id/info
* \return subdevice part of element identificator
* \return subdevice part of element identifier
*/
unsigned int snd_ctl_elem_info_get_subdevice(const snd_ctl_elem_info_t *obj)
{
@ -1690,9 +1690,9 @@ unsigned int snd_ctl_elem_info_get_subdevice(const snd_ctl_elem_info_t *obj)
}
/**
* \brief Get name part of CTL element identificator of a CTL element id/info
* \brief Get name part of CTL element identifier of a CTL element id/info
* \param obj CTL element id/info
* \return name part of element identificator
* \return name part of element identifier
*/
const char *snd_ctl_elem_info_get_name(const snd_ctl_elem_info_t *obj)
{
@ -1701,9 +1701,9 @@ const char *snd_ctl_elem_info_get_name(const snd_ctl_elem_info_t *obj)
}
/**
* \brief Get index part of CTL element identificator of a CTL element id/info
* \brief Get index part of CTL element identifier of a CTL element id/info
* \param obj CTL element id/info
* \return index part of element identificator
* \return index part of element identifier
*/
unsigned int snd_ctl_elem_info_get_index(const snd_ctl_elem_info_t *obj)
{
@ -1712,9 +1712,9 @@ unsigned int snd_ctl_elem_info_get_index(const snd_ctl_elem_info_t *obj)
}
/**
* \brief Set CTL element identificator of a CTL element id/info
* \brief Set CTL element identifier of a CTL element id/info
* \param obj CTL element id/info
* \param ptr CTL element identificator
* \param ptr CTL element identifier
*/
void snd_ctl_elem_info_set_id(snd_ctl_elem_info_t *obj, const snd_ctl_elem_id_t *ptr)
{
@ -1723,9 +1723,9 @@ void snd_ctl_elem_info_set_id(snd_ctl_elem_info_t *obj, const snd_ctl_elem_id_t
}
/**
* \brief Set element numeric identificator of a CTL element id/info
* \brief Set element numeric identifier of a CTL element id/info
* \param obj CTL element id/info
* \param val element numeric identificator
* \param val element numeric identifier
*/
void snd_ctl_elem_info_set_numid(snd_ctl_elem_info_t *obj, unsigned int val)
{
@ -1734,9 +1734,9 @@ void snd_ctl_elem_info_set_numid(snd_ctl_elem_info_t *obj, unsigned int val)
}
/**
* \brief Set interface part of CTL element identificator of a CTL element id/info
* \brief Set interface part of CTL element identifier of a CTL element id/info
* \param obj CTL element id/info
* \param val interface part of element identificator
* \param val interface part of element identifier
*/
void snd_ctl_elem_info_set_interface(snd_ctl_elem_info_t *obj, snd_ctl_elem_iface_t val)
{
@ -1745,9 +1745,9 @@ void snd_ctl_elem_info_set_interface(snd_ctl_elem_info_t *obj, snd_ctl_elem_ifac
}
/**
* \brief Set device part of CTL element identificator of a CTL element id/info
* \brief Set device part of CTL element identifier of a CTL element id/info
* \param obj CTL element id/info
* \param val device part of element identificator
* \param val device part of element identifier
*/
void snd_ctl_elem_info_set_device(snd_ctl_elem_info_t *obj, unsigned int val)
{
@ -1756,9 +1756,9 @@ void snd_ctl_elem_info_set_device(snd_ctl_elem_info_t *obj, unsigned int val)
}
/**
* \brief Set subdevice part of CTL element identificator of a CTL element id/info
* \brief Set subdevice part of CTL element identifier of a CTL element id/info
* \param obj CTL element id/info
* \param val subdevice part of element identificator
* \param val subdevice part of element identifier
*/
void snd_ctl_elem_info_set_subdevice(snd_ctl_elem_info_t *obj, unsigned int val)
{
@ -1767,9 +1767,9 @@ void snd_ctl_elem_info_set_subdevice(snd_ctl_elem_info_t *obj, unsigned int val)
}
/**
* \brief Set name part of CTL element identificator of a CTL element id/info
* \brief Set name part of CTL element identifier of a CTL element id/info
* \param obj CTL element id/info
* \param val name part of element identificator
* \param val name part of element identifier
*/
void snd_ctl_elem_info_set_name(snd_ctl_elem_info_t *obj, const char *val)
{
@ -1778,9 +1778,9 @@ void snd_ctl_elem_info_set_name(snd_ctl_elem_info_t *obj, const char *val)
}
/**
* \brief Set index part of CTL element identificator of a CTL element id/info
* \brief Set index part of CTL element identifier of a CTL element id/info
* \param obj CTL element id/info
* \param val index part of element identificator
* \param val index part of element identifier
*/
void snd_ctl_elem_info_set_index(snd_ctl_elem_info_t *obj, unsigned int val)
{
@ -1841,9 +1841,9 @@ void snd_ctl_elem_value_copy(snd_ctl_elem_value_t *dst, const snd_ctl_elem_value
}
/**
* \brief Get CTL element identificator of a CTL element id/value
* \brief Get CTL element identifier of a CTL element id/value
* \param obj CTL element id/value
* \param ptr Pointer to returned CTL element identificator
* \param ptr Pointer to returned CTL element identifier
*/
void snd_ctl_elem_value_get_id(const snd_ctl_elem_value_t *obj, snd_ctl_elem_id_t *ptr)
{
@ -1852,9 +1852,9 @@ void snd_ctl_elem_value_get_id(const snd_ctl_elem_value_t *obj, snd_ctl_elem_id_
}
/**
* \brief Get element numeric identificator of a CTL element id/value
* \brief Get element numeric identifier of a CTL element id/value
* \param obj CTL element id/value
* \return element numeric identificator
* \return element numeric identifier
*/
unsigned int snd_ctl_elem_value_get_numid(const snd_ctl_elem_value_t *obj)
{
@ -1863,9 +1863,9 @@ unsigned int snd_ctl_elem_value_get_numid(const snd_ctl_elem_value_t *obj)
}
/**
* \brief Get interface part of CTL element identificator of a CTL element id/value
* \brief Get interface part of CTL element identifier of a CTL element id/value
* \param obj CTL element id/value
* \return interface part of element identificator
* \return interface part of element identifier
*/
snd_ctl_elem_iface_t snd_ctl_elem_value_get_interface(const snd_ctl_elem_value_t *obj)
{
@ -1874,9 +1874,9 @@ snd_ctl_elem_iface_t snd_ctl_elem_value_get_interface(const snd_ctl_elem_value_t
}
/**
* \brief Get device part of CTL element identificator of a CTL element id/value
* \brief Get device part of CTL element identifier of a CTL element id/value
* \param obj CTL element id/value
* \return device part of element identificator
* \return device part of element identifier
*/
unsigned int snd_ctl_elem_value_get_device(const snd_ctl_elem_value_t *obj)
{
@ -1885,9 +1885,9 @@ unsigned int snd_ctl_elem_value_get_device(const snd_ctl_elem_value_t *obj)
}
/**
* \brief Get subdevice part of CTL element identificator of a CTL element id/value
* \brief Get subdevice part of CTL element identifier of a CTL element id/value
* \param obj CTL element id/value
* \return subdevice part of element identificator
* \return subdevice part of element identifier
*/
unsigned int snd_ctl_elem_value_get_subdevice(const snd_ctl_elem_value_t *obj)
{
@ -1896,9 +1896,9 @@ unsigned int snd_ctl_elem_value_get_subdevice(const snd_ctl_elem_value_t *obj)
}
/**
* \brief Get name part of CTL element identificator of a CTL element id/value
* \brief Get name part of CTL element identifier of a CTL element id/value
* \param obj CTL element id/value
* \return name part of element identificator
* \return name part of element identifier
*/
const char *snd_ctl_elem_value_get_name(const snd_ctl_elem_value_t *obj)
{
@ -1907,9 +1907,9 @@ const char *snd_ctl_elem_value_get_name(const snd_ctl_elem_value_t *obj)
}
/**
* \brief Get index part of CTL element identificator of a CTL element id/value
* \brief Get index part of CTL element identifier of a CTL element id/value
* \param obj CTL element id/value
* \return index part of element identificator
* \return index part of element identifier
*/
unsigned int snd_ctl_elem_value_get_index(const snd_ctl_elem_value_t *obj)
{
@ -1918,9 +1918,9 @@ unsigned int snd_ctl_elem_value_get_index(const snd_ctl_elem_value_t *obj)
}
/**
* \brief Set CTL element identificator of a CTL element id/value
* \brief Set CTL element identifier of a CTL element id/value
* \param obj CTL element id/value
* \param ptr CTL element identificator
* \param ptr CTL element identifier
*/
void snd_ctl_elem_value_set_id(snd_ctl_elem_value_t *obj, const snd_ctl_elem_id_t *ptr)
{
@ -1929,9 +1929,9 @@ void snd_ctl_elem_value_set_id(snd_ctl_elem_value_t *obj, const snd_ctl_elem_id_
}
/**
* \brief Set element numeric identificator of a CTL element id/value
* \brief Set element numeric identifier of a CTL element id/value
* \param obj CTL element id/value
* \param val element numeric identificator
* \param val element numeric identifier
*/
void snd_ctl_elem_value_set_numid(snd_ctl_elem_value_t *obj, unsigned int val)
{
@ -1940,9 +1940,9 @@ void snd_ctl_elem_value_set_numid(snd_ctl_elem_value_t *obj, unsigned int val)
}
/**
* \brief Set interface part of CTL element identificator of a CTL element id/value
* \brief Set interface part of CTL element identifier of a CTL element id/value
* \param obj CTL element id/value
* \param val interface part of element identificator
* \param val interface part of element identifier
*/
void snd_ctl_elem_value_set_interface(snd_ctl_elem_value_t *obj, snd_ctl_elem_iface_t val)
{
@ -1951,9 +1951,9 @@ void snd_ctl_elem_value_set_interface(snd_ctl_elem_value_t *obj, snd_ctl_elem_if
}
/**
* \brief Set device part of CTL element identificator of a CTL element id/value
* \brief Set device part of CTL element identifier of a CTL element id/value
* \param obj CTL element id/value
* \param val device part of element identificator
* \param val device part of element identifier
*/
void snd_ctl_elem_value_set_device(snd_ctl_elem_value_t *obj, unsigned int val)
{
@ -1962,9 +1962,9 @@ void snd_ctl_elem_value_set_device(snd_ctl_elem_value_t *obj, unsigned int val)
}
/**
* \brief Set subdevice part of CTL element identificator of a CTL element id/value
* \brief Set subdevice part of CTL element identifier of a CTL element id/value
* \param obj CTL element id/value
* \param val subdevice part of element identificator
* \param val subdevice part of element identifier
*/
void snd_ctl_elem_value_set_subdevice(snd_ctl_elem_value_t *obj, unsigned int val)
{
@ -1973,9 +1973,9 @@ void snd_ctl_elem_value_set_subdevice(snd_ctl_elem_value_t *obj, unsigned int va
}
/**
* \brief Set name part of CTL element identificator of a CTL element id/value
* \brief Set name part of CTL element identifier of a CTL element id/value
* \param obj CTL element id/value
* \param val name part of element identificator
* \param val name part of element identifier
*/
void snd_ctl_elem_value_set_name(snd_ctl_elem_value_t *obj, const char *val)
{
@ -1984,9 +1984,9 @@ void snd_ctl_elem_value_set_name(snd_ctl_elem_value_t *obj, const char *val)
}
/**
* \brief Set index part of CTL element identificator of a CTL element id/value
* \brief Set index part of CTL element identifier of a CTL element id/value
* \param obj CTL element id/value
* \param val index part of element identificator
* \param val index part of element identifier
*/
void snd_ctl_elem_value_set_index(snd_ctl_elem_value_t *obj, unsigned int val)
{

32
src/control/hcontrol.c
View file

@ -10,7 +10,7 @@
* See \ref hcontrol page for more details.
*/
/*
* Control Interface - highlevel API
* Control Interface - high level API
* Copyright (c) 2000 by Jaroslav Kysela <perex@suse.cz>
* Copyright (c) 2001 by Abramo Bagnara <abramo@alsa-project.org>
*
@ -497,7 +497,7 @@ snd_hctl_elem_t *snd_hctl_elem_prev(snd_hctl_elem_t *elem)
/**
* \brief Search an HCTL element
* \param hctl HCTL handle
* \param id Element identificator
* \param id Element identifier
* \return pointer to found HCTL element or NULL if it does not exists
*/
snd_hctl_elem_t *snd_hctl_find_elem(snd_hctl_t *hctl, const snd_ctl_elem_id_t *id)
@ -764,9 +764,9 @@ snd_hctl_t *snd_hctl_elem_get_hctl(snd_hctl_elem_t *elem)
}
/**
* \brief Get CTL element identificator of a CTL element id/value
* \brief Get CTL element identifier of a CTL element id/value
* \param obj CTL element id/value
* \param ptr Pointer to returned CTL element identificator
* \param ptr Pointer to returned CTL element identifier
*/
void snd_hctl_elem_get_id(const snd_hctl_elem_t *obj, snd_ctl_elem_id_t *ptr)
{
@ -775,9 +775,9 @@ void snd_hctl_elem_get_id(const snd_hctl_elem_t *obj, snd_ctl_elem_id_t *ptr)
}
/**
* \brief Get element numeric identificator of a CTL element id/value
* \brief Get element numeric identifier of a CTL element id/value
* \param obj CTL element id/value
* \return element numeric identificator
* \return element numeric identifier
*/
unsigned int snd_hctl_elem_get_numid(const snd_hctl_elem_t *obj)
{
@ -786,9 +786,9 @@ unsigned int snd_hctl_elem_get_numid(const snd_hctl_elem_t *obj)
}
/**
* \brief Get interface part of CTL element identificator of a CTL element id/value
* \brief Get interface part of CTL element identifier of a CTL element id/value
* \param obj CTL element id/value
* \return interface part of element identificator
* \return interface part of element identifier
*/
snd_ctl_elem_iface_t snd_hctl_elem_get_interface(const snd_hctl_elem_t *obj)
{
@ -797,9 +797,9 @@ snd_ctl_elem_iface_t snd_hctl_elem_get_interface(const snd_hctl_elem_t *obj)
}
/**
* \brief Get device part of CTL element identificator of a CTL element id/value
* \brief Get device part of CTL element identifier of a CTL element id/value
* \param obj CTL element id/value
* \return device part of element identificator
* \return device part of element identifier
*/
unsigned int snd_hctl_elem_get_device(const snd_hctl_elem_t *obj)
{
@ -808,9 +808,9 @@ unsigned int snd_hctl_elem_get_device(const snd_hctl_elem_t *obj)
}
/**
* \brief Get subdevice part of CTL element identificator of a CTL element id/value
* \brief Get subdevice part of CTL element identifier of a CTL element id/value
* \param obj CTL element id/value
* \return subdevice part of element identificator
* \return subdevice part of element identifier
*/
unsigned int snd_hctl_elem_get_subdevice(const snd_hctl_elem_t *obj)
{
@ -819,9 +819,9 @@ unsigned int snd_hctl_elem_get_subdevice(const snd_hctl_elem_t *obj)
}
/**
* \brief Get name part of CTL element identificator of a CTL element id/value
* \brief Get name part of CTL element identifier of a CTL element id/value
* \param obj CTL element id/value
* \return name part of element identificator
* \return name part of element identifier
*/
const char *snd_hctl_elem_get_name(const snd_hctl_elem_t *obj)
{
@ -830,9 +830,9 @@ const char *snd_hctl_elem_get_name(const snd_hctl_elem_t *obj)
}
/**
* \brief Get index part of CTL element identificator of a CTL element id/value
* \brief Get index part of CTL element identifier of a CTL element id/value
* \param obj CTL element id/value
* \return index part of element identificator
* \return index part of element identifier
*/
unsigned int snd_hctl_elem_get_index(const snd_hctl_elem_t *obj)
{

2
src/control/setup.c
View file

@ -282,7 +282,7 @@ static int snd_config_get_ctl_elem_value(snd_config_t *conf,
case SND_CTL_ELEM_TYPE_IEC958:
break;
default:
SNDERR("Unknow control type: %d", type);
SNDERR("Unknown control type: %d", type);
return -EINVAL;
}
}

52
src/mixer/simple.c
View file

@ -1038,7 +1038,7 @@ int snd_mixer_selem_register(snd_mixer_t *mixer, void *options ATTRIBUTE_UNUSED,
/**
* \brief Find a mixer simple element
* \param mixer Mixer handle
* \param id Mixer simple element identificator
* \param id Mixer simple element identifier
* \return mixer simple element handle or NULL if not found
*/
snd_mixer_elem_t *snd_mixer_find_selem(snd_mixer_t *mixer,
@ -1059,9 +1059,9 @@ snd_mixer_elem_t *snd_mixer_find_selem(snd_mixer_t *mixer,
}
/**
* \brief Get mixer simple element identificator
* \brief Get mixer simple element identifier
* \param elem Mixer simple element handle
* \param id returned mixer simple element identificator
* \param id returned mixer simple element identifier
*/
void snd_mixer_selem_get_id(snd_mixer_elem_t *elem,
snd_mixer_selem_id_t *id)
@ -1074,9 +1074,9 @@ void snd_mixer_selem_get_id(snd_mixer_elem_t *elem,
}
/**
* \brief Get name part of mixer simple element identificator
* \brief Get name part of mixer simple element identifier
* \param elem Mixer simple element handle
* \return name part of simple element identificator
* \return name part of simple element identifier
*/
const char *snd_mixer_selem_get_name(snd_mixer_elem_t *elem)
{
@ -1088,9 +1088,9 @@ const char *snd_mixer_selem_get_name(snd_mixer_elem_t *elem)
}
/**
* \brief Get index part of mixer simple element identificator
* \brief Get index part of mixer simple element identifier
* \param elem Mixer simple element handle
* \return index part of simple element identificator
* \return index part of simple element identifier
*/
unsigned int snd_mixer_selem_get_index(snd_mixer_elem_t *elem)
{
@ -1199,7 +1199,7 @@ static int _snd_mixer_selem_set_switch_all(snd_mixer_elem_t *elem, int dir, int
/**
* \brief Return name of mixer simple element channel
* \param channel mixer simple element channel identificator
* \param channel mixer simple element channel identifier
* \return channel name
*/
const char *snd_mixer_selem_channel_name(snd_mixer_selem_channel_id_t channel)
@ -1255,7 +1255,7 @@ int snd_mixer_selem_is_playback_mono(snd_mixer_elem_t *elem)
/**
* \brief Get info about channels of playback stream of a mixer simple element
* \param elem Mixer simple element handle
* \param channel Mixer simple element channel identificator
* \param channel Mixer simple element channel identifier
* \return 0 if channel is not present, 1 if present
*/
int snd_mixer_selem_has_playback_channel(snd_mixer_elem_t *elem, snd_mixer_selem_channel_id_t channel)
@ -1362,7 +1362,7 @@ int snd_mixer_selem_has_playback_switch_joined(snd_mixer_elem_t *elem)
/**
* \brief Return value of playback volume control of a mixer simple element
* \param elem Mixer simple element handle
* \param channel mixer simple element channel identificator
* \param channel mixer simple element channel identifier
* \param value pointer to returned value
* \return 0 on success otherwise a negative error code
*/
@ -1383,7 +1383,7 @@ int snd_mixer_selem_get_playback_volume(snd_mixer_elem_t *elem, snd_mixer_selem_
/**
* \brief Return value of playback switch control of a mixer simple element
* \param elem Mixer simple element handle
* \param channel mixer simple element channel identificator
* \param channel mixer simple element channel identifier
* \param value pointer to returned value
* \return 0 on success otherwise a negative error code
*/
@ -1404,7 +1404,7 @@ int snd_mixer_selem_get_playback_switch(snd_mixer_elem_t *elem, snd_mixer_selem_
/**
* \brief Set value of playback volume control of a mixer simple element
* \param elem Mixer simple element handle
* \param channel mixer simple element channel identificator
* \param channel mixer simple element channel identifier
* \param value control value
* \return 0 on success otherwise a negative error code
*/
@ -1449,7 +1449,7 @@ int snd_mixer_selem_set_playback_volume_all(snd_mixer_elem_t *elem, long value)
/**
* \brief Set value of playback switch control of a mixer simple element
* \param elem Mixer simple element handle
* \param channel mixer simple element channel identificator
* \param channel mixer simple element channel identifier
* \param value control value
* \return 0 on success otherwise a negative error code
*/
@ -1508,7 +1508,7 @@ int snd_mixer_selem_is_capture_mono(snd_mixer_elem_t *elem)
/**
* \brief Get info about channels of capture stream of a mixer simple element
* \param elem Mixer simple element handle
* \param channel Mixer simple element channel identificator
* \param channel Mixer simple element channel identifier
* \return 0 if channel is not present, 1 if present
*/
int snd_mixer_selem_has_capture_channel(snd_mixer_elem_t *elem, snd_mixer_selem_channel_id_t channel)
@ -1644,7 +1644,7 @@ int snd_mixer_selem_get_capture_group(snd_mixer_elem_t *elem)
/**
* \brief Return value of capture volume control of a mixer simple element
* \param elem Mixer simple element handle
* \param channel mixer simple element channel identificator
* \param channel mixer simple element channel identifier
* \param value pointer to returned value
* \return 0 on success otherwise a negative error code
*/
@ -1665,7 +1665,7 @@ int snd_mixer_selem_get_capture_volume(snd_mixer_elem_t *elem, snd_mixer_selem_c
/**
* \brief Return value of capture switch control of a mixer simple element
* \param elem Mixer simple element handle
* \param channel mixer simple element channel identificator
* \param channel mixer simple element channel identifier
* \param value pointer to returned value
* \return 0 on success otherwise a negative error code
*/
@ -1686,7 +1686,7 @@ int snd_mixer_selem_get_capture_switch(snd_mixer_elem_t *elem, snd_mixer_selem_c
/**
* \brief Set value of capture volume control of a mixer simple element
* \param elem Mixer simple element handle
* \param channel mixer simple element channel identificator
* \param channel mixer simple element channel identifier
* \param value control value
* \return 0 on success otherwise a negative error code
*/
@ -1731,7 +1731,7 @@ int snd_mixer_selem_set_capture_volume_all(snd_mixer_elem_t *elem, long value)
/**
* \brief Set value of capture switch control of a mixer simple element
* \param elem Mixer simple element handle
* \param channel mixer simple element channel identificator
* \param channel mixer simple element channel identifier
* \param value control value
* \return 0 on success otherwise a negative error code
*/
@ -1817,8 +1817,8 @@ void snd_mixer_selem_id_copy(snd_mixer_selem_id_t *dst, const snd_mixer_selem_id
}
/**
* \brief Get name part of a mixer simple element identificator
* \param obj Mixer simple element identificator
* \brief Get name part of a mixer simple element identifier
* \param obj Mixer simple element identifier
* \return name part
*/
const char *snd_mixer_selem_id_get_name(const snd_mixer_selem_id_t *obj)
@ -1828,8 +1828,8 @@ const char *snd_mixer_selem_id_get_name(const snd_mixer_selem_id_t *obj)
}
/**
* \brief Get index part of a mixer simple element identificator
* \param obj Mixer simple element identificator
* \brief Get index part of a mixer simple element identifier
* \param obj Mixer simple element identifier
* \return index part
*/
unsigned int snd_mixer_selem_id_get_index(const snd_mixer_selem_id_t *obj)
@ -1839,8 +1839,8 @@ unsigned int snd_mixer_selem_id_get_index(const snd_mixer_selem_id_t *obj)
}
/**
* \brief Set name part of a mixer simple element identificator
* \param obj Mixer simple element identificator
* \brief Set name part of a mixer simple element identifier
* \param obj Mixer simple element identifier
* \param val name part
*/
void snd_mixer_selem_id_set_name(snd_mixer_selem_id_t *obj, const char *val)
@ -1850,8 +1850,8 @@ void snd_mixer_selem_id_set_name(snd_mixer_selem_id_t *obj, const char *val)
}
/**
* \brief Set index part of a mixer simple element identificator
* \param obj Mixer simple element identificator
* \brief Set index part of a mixer simple element identifier
* \param obj Mixer simple element identifier
* \param val index part
*/
void snd_mixer_selem_id_set_index(snd_mixer_selem_id_t *obj, unsigned int val)

100
src/pcm/pcm.c
View file

@ -67,21 +67,21 @@ representation via digital to analog converters (DAC).</P>
specific time. One frame might contain one sample (when only one converter is
used - mono) or more samples (for example: stereo has signals from two converters
recorded at same time). Digital audio stream contains collection of frames
recorded at boundaries of continous time periods.</P>
recorded at boundaries of continuous time periods.</P>
\section pcm_general_overview General overview
ALSA uses the ring buffer to store outgoing (playback) and incoming (capture,
record) samples. There are two pointers being mantained to allow
record) samples. There are two pointers being maintained to allow
a precise communication between application and device pointing to current
processed sample by hardware and last processed sample by application.
The modern audio chips allow to program the transfer time periods.
It means that the stream of samples is divided to small chunks. Device
acknowledges to application when the transfer of a chunk is complete.
\section pcm_transfer Transfer methods in unix environments
\section pcm_transfer Transfer methods in UNIX environments
In the unix environment, data chunk acknowledges are received via standard I/O
In the UNIX environment, data chunk acknowledges are received via standard I/O
calls or event waiting routines (poll or select function). To accomplish
this list, the asynchronous notification of acknowledges should be listed
here. The ALSA implementation for these methods is described in
@ -205,7 +205,7 @@ to leave this state.
The full list of formats present the \link ::snd_pcm_format_t \endlink type.
The 24-bit linear samples uses 32-bit physical space, but the sample is
stored in low three bits. Some hardware does not support processing of full
range, thus you may get the significative bits for linear samples via
range, thus you may get the significant bits for linear samples via
\link ::snd_pcm_hw_params_get_sbits \endlink function. The example: ICE1712
chips support 32-bit sample processing, but low byte is ignored (playback)
or zero (capture). The function \link ::snd_pcm_hw_params_get_sbits() \endlink
@ -231,7 +231,7 @@ interleaved transfers: \link ::snd_pcm_writei \endlink,
these functions: \link ::snd_pcm_writen \endlink and \link ::snd_pcm_readn
\endlink.
\subsection alsa_mmap_rw Direct Read / Write transfer (via mmaped areas)
\subsection alsa_mmap_rw Direct Read / Write transfer (via mmap'ed areas)
There are two functions for this kind of transfer. Application can get an
access to memory areas via \link ::snd_pcm_mmap_begin \endlink function.
@ -257,7 +257,7 @@ and \link ::snd_pcm_writen() \endlink functions.
The ALSA PCM device uses two groups of PCM related parameters. The hardware
parameters contains the stream description like format, rate, count of
channels, ring buffer size etc. The software parameters contains the
software (driver) related parameters. The communicatino behaviour can be
software (driver) related parameters. The communication behaviour can be
controlled via these parameters, like automatic start, automatic stop,
interrupting (chunk acknowledge) etc. The software parameters can be
modified at any time (when valid hardware parameters are set). It includes
@ -345,7 +345,7 @@ the filled (used) samples in ring buffer.
\par Silence threshold
The silence threshold specifies count of samples filled with silence
ahead of the current application pointer for playback. It is useable
ahead of the current application pointer for playback. It is usable
for applications when an overrun is possible (like tasks depending on
network I/O etc.). If application wants to manage the ahead samples itself,
the \link ::snd_pcm_rewind() \endlink function allows to forget the last
@ -360,7 +360,7 @@ These parameters can be obtained: the current stream state -
update \link ::snd_pcm_status_get_tstamp \endlink, delay in samples -
\link ::snd_pcm_status_get_delay \endlink, available count in samples -
\link ::snd_pcm_status_get_avail \endlink, maximum available samples -
\link ::snd_pcm_status_get_avail_max \endlink, ADC overrange count in
\link ::snd_pcm_status_get_avail_max \endlink, ADC over-range count in
samples - \link ::snd_pcm_status_get_overrange \endlink. The last two
parameters - avail_max and overrange are reset to zero after the status
call.
@ -368,7 +368,7 @@ call.
\subsection pcm_status_fast Obtaining fast device status
The function \link ::snd_pcm_avail_update \endlink updates the current
available count of samples for writting (playback) or filled samples for
available count of samples for writing (playback) or filled samples for
reading (capture).
<p>
The function \link ::snd_pcm_delay \endlink returns the delay in samples.
@ -388,11 +388,11 @@ if successfully finishes, otherwise the state \link ::SND_PCM_STATE_OPEN
\par snd_pcm_prepare
The \link ::snd_pcm_prepare \endlink function enters the
\link ::SND_PCM_STATE_PREPARED \endlink after a successfull finish.
\link ::SND_PCM_STATE_PREPARED \endlink after a successful finish.
\par snd_pcm_start
The \link ::snd_pcm_start \endlink function enters
the \link ::SND_PCM_STATE_RUNNING \endlink after a successfull finish.
the \link ::SND_PCM_STATE_RUNNING \endlink after a successful finish.
\par snd_pcm_drop
The \link ::snd_pcm_drop \endlink function enters the
@ -428,9 +428,9 @@ case, the linking means that all operations are synchronized. Because the
drivers cannot guarantee the synchronization (sample resolution) on hardware
lacking this feature, the \link ::snd_pcm_info_get_sync \endlink function
returns synchronization ID - \link ::snd_pcm_sync_id_t \endlink, which is equal
for hardware synchronizated streams. When the \link ::snd_pcm_link \endlink
for hardware synchronized streams. When the \link ::snd_pcm_link \endlink
function is called, all operations managing the stream state for these two
streams are joined. The oposite function is \link ::snd_pcm_unlink \endlink.
streams are joined. The opposite function is \link ::snd_pcm_unlink \endlink.
\section pcm_dev_names PCM naming conventions
@ -506,7 +506,7 @@ plug:SLAVE=hw
\subsection pcm_dev_names_shm Shared memory device
The shm device uses the shm plugin. The two arguments (in order: SOCKET,PCM) specify
unix socket name (for example /tmp/alsa.socket) for server communication and server's PCM name.
UNIX socket name (for example /tmp/alsa.socket) for server communication and server's PCM name.
Example:
@ -709,12 +709,12 @@ int snd_pcm_info(snd_pcm_t *pcm, snd_pcm_info_t *info)
return pcm->ops->info(pcm->op_arg, info);
}
/** \brief Install one PCM hardware configuration choosen from a configuration space and #snd_pcm_prepare it
/** \brief Install one PCM hardware configuration chosen from a configuration space and #snd_pcm_prepare it
* \param pcm PCM handle
* \param params Configuration space definition container
* \return 0 on success otherwise a negative error code
*
* The configuration is choosen fixing single parameters in this order:
* The configuration is chosen fixing single parameters in this order:
* first access, first format, first subformat, min channels, min rate,
* min period time, max buffer size, min tick time
*/
@ -890,7 +890,7 @@ int snd_pcm_drop(snd_pcm_t *pcm)
* \brief Stop a PCM preserving pending frames
* \param pcm PCM handle
* \return 0 on success otherwise a negative error code
* \retval -ESTRPIPE a suspend event occured
* \retval -ESTRPIPE a suspend event occurred
*
* For playback wait for all pending frames to be played and then stop
* the PCM.
@ -939,12 +939,12 @@ snd_pcm_sframes_t snd_pcm_rewind(snd_pcm_t *pcm, snd_pcm_uframes_t frames)
* \return a positive number of frames actually written otherwise a
* negative error code
* \retval -EBADFD PCM is not in the right state (#SND_PCM_STATE_PREPARED or #SND_PCM_STATE_RUNNING)
* \retval -EPIPE an underrun occured
* \retval -ESTRPIPE a suspend event occured (stream is suspended and waiting for an application recovery)
* \retval -EPIPE an underrun occurred
* \retval -ESTRPIPE a suspend event occurred (stream is suspended and waiting for an application recovery)
*
* If the blocking behaviour is selected, then routine waits until
* all requested bytes are played or put to the playback ring buffer.
* The count of bytes can be less only if a signal or underrun occured.
* The count of bytes can be less only if a signal or underrun occurred.
*
* If the non-blocking behaviour is selected, then routine doesn't wait at all.
*/
@ -965,12 +965,12 @@ snd_pcm_sframes_t snd_pcm_writei(snd_pcm_t *pcm, const void *buffer, snd_pcm_ufr
* \return a positive number of frames actually written otherwise a
* negative error code
* \retval -EBADFD PCM is not in the right state (#SND_PCM_STATE_PREPARED or #SND_PCM_STATE_RUNNING)
* \retval -EPIPE an underrun occured
* \retval -ESTRPIPE a suspend event occured (stream is suspended and waiting for an application recovery)
* \retval -EPIPE an underrun occurred
* \retval -ESTRPIPE a suspend event occurred (stream is suspended and waiting for an application recovery)
*
* If the blocking behaviour is selected, then routine waits until
* all requested bytes are played or put to the playback ring buffer.
* The count of bytes can be less only if a signal or underrun occured.
* The count of bytes can be less only if a signal or underrun occurred.
*
* If the non-blocking behaviour is selected, then routine doesn't wait at all.
*/
@ -991,12 +991,12 @@ snd_pcm_sframes_t snd_pcm_writen(snd_pcm_t *pcm, void **bufs, snd_pcm_uframes_t
* \return a positive number of frames actually read otherwise a
* negative error code
* \retval -EBADFD PCM is not in the right state (#SND_PCM_STATE_PREPARED or #SND_PCM_STATE_RUNNING)
* \retval -EPIPE an overrun occured
* \retval -ESTRPIPE a suspend event occured (stream is suspended and waiting for an application recovery)
* \retval -EPIPE an overrun occurred
* \retval -ESTRPIPE a suspend event occurred (stream is suspended and waiting for an application recovery)
*
* If the blocking behaviour was selected, then routine waits until
* all requested bytes are filled. The count of bytes can be less only
* if a signal or underrun occured.
* if a signal or underrun occurred.
*
* If the non-blocking behaviour is selected, then routine doesn't wait at all.
*/
@ -1017,12 +1017,12 @@ snd_pcm_sframes_t snd_pcm_readi(snd_pcm_t *pcm, void *buffer, snd_pcm_uframes_t
* \return a positive number of frames actually read otherwise a
* negative error code
* \retval -EBADFD PCM is not in the right state (#SND_PCM_STATE_PREPARED or #SND_PCM_STATE_RUNNING)
* \retval -EPIPE an overrun occured
* \retval -ESTRPIPE a suspend event occured (stream is suspended and waiting for an application recovery)
* \retval -EPIPE an overrun occurred
* \retval -ESTRPIPE a suspend event occurred (stream is suspended and waiting for an application recovery)
*
* If the blocking behaviour was selected, then routine waits until
* all requested bytes are filled. The count of bytes can be less only
* if a signal or underrun occured.
* if a signal or underrun occurred.
*
* If the non-blocking behaviour is selected, then routine doesn't wait at all.
*/
@ -1776,7 +1776,7 @@ int snd_pcm_open_slave(snd_pcm_t **pcmp, snd_config_t *root,
* \param pcm PCM handle
* \param timeout maximum time in milliseconds to wait
* \return a positive value on success otherwise a negative error code
* \retval 0 timeout occured
* \retval 0 timeout occurred
* \retval 1 PCM stream is ready for I/O
*/
int snd_pcm_wait(snd_pcm_t *pcm, int timeout)
@ -2284,7 +2284,7 @@ int snd_pcm_hw_params_get_rate_numden(const snd_pcm_hw_params_t *params,
/**
* \brief Get sample resolution info from a configuration space
* \param params Configuration space
* \return significative bits in sample otherwise a negative error code if the info is not available
* \return signification bits in sample otherwise a negative error code if the info is not available
*/
int snd_pcm_hw_params_get_sbits(const snd_pcm_hw_params_t *params)
{
@ -2294,9 +2294,9 @@ int snd_pcm_hw_params_get_sbits(const snd_pcm_hw_params_t *params)
}
/**
* \brief Get hardare fifo size info from a configuration space
* \brief Get hard are FIFO size info from a configuration space
* \param params Configuration space
* \return fifo size in frames otherwise a negative error code if the info is not available
* \return FIFO size in frames otherwise a negative error code if the info is not available
*/
int snd_pcm_hw_params_get_fifo_size(const snd_pcm_hw_params_t *params)
{
@ -3024,7 +3024,7 @@ int snd_pcm_hw_params_set_channels_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t *p
* \param pcm PCM handle
* \param params Configuration space
* \param val target channels count
* \return choosen channels count
* \return chosen channels count
*/
unsigned int snd_pcm_hw_params_set_channels_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val)
{
@ -3187,9 +3187,9 @@ int snd_pcm_hw_params_set_rate_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t *param
* \param pcm PCM handle
* \param params Configuration space
* \param val approximate target rate
* \return approximate choosen rate
* \return approximate chosen rate
*
* target/choosen exact value is <,=,> val following dir (-1,0,1)
* target/chosen exact value is <,=,> val following dir (-1,0,1)
*/
unsigned int snd_pcm_hw_params_set_rate_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val, int *dir)
{
@ -3359,9 +3359,9 @@ int snd_pcm_hw_params_set_period_time_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t
* \param pcm PCM handle
* \param params Configuration space
* \param val approximate target period duration in us
* \return approximate choosen period duration in us
* \return approximate chosen period duration in us
*
* target/choosen exact value is <,=,> val following dir (-1,0,1)
* target/chosen exact value is <,=,> val following dir (-1,0,1)
*/
unsigned int snd_pcm_hw_params_set_period_time_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val, int *dir)
{
@ -3541,9 +3541,9 @@ int snd_pcm_hw_params_set_period_size_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t
* \param pcm PCM handle
* \param params Configuration space
* \param val approximate target period size in frames
* \return approximate choosen period size in frames
* \return approximate chosen period size in frames
*
* target/choosen exact value is <,=,> val following dir (-1,0,1)
* target/chosen exact value is <,=,> val following dir (-1,0,1)
*/
snd_pcm_uframes_t snd_pcm_hw_params_set_period_size_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_uframes_t val, int *dir)
{
@ -3723,9 +3723,9 @@ int snd_pcm_hw_params_set_periods_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t *pa
* \param pcm PCM handle
* \param params Configuration space
* \param val approximate target periods per buffer
* \return approximate choosen periods per buffer
* \return approximate chosen periods per buffer
*
* target/choosen exact value is <,=,> val following dir (-1,0,1)
* target/chosen exact value is <,=,> val following dir (-1,0,1)
*/
unsigned int snd_pcm_hw_params_set_periods_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val, int *dir)
{
@ -3905,9 +3905,9 @@ int snd_pcm_hw_params_set_buffer_time_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t
* \param pcm PCM handle
* \param params Configuration space
* \param val approximate target buffer duration in us
* \return approximate choosen buffer duration in us
* \return approximate chosen buffer duration in us
*
* target/choosen exact value is <,=,> val following dir (-1,0,1)
* target/chosen exact value is <,=,> val following dir (-1,0,1)
*/
unsigned int snd_pcm_hw_params_set_buffer_time_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val, int *dir)
{
@ -3937,7 +3937,7 @@ unsigned int snd_pcm_hw_params_set_buffer_time_first(snd_pcm_t *pcm, snd_pcm_hw_
}
/**
* \brief Restrict a configuration space to contain only its maximum bufferd time
* \brief Restrict a configuration space to contain only its maximum buffered time
* \param pcm PCM handle
* \param params Configuration space
* \param dir Sub unit direction
@ -4083,9 +4083,9 @@ int snd_pcm_hw_params_set_buffer_size_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t
* \param pcm PCM handle
* \param params Configuration space
* \param val approximate target buffer size in frames
* \return approximate choosen buffer size in frames
* \return approximate chosen buffer size in frames
*
* target/choosen exact value is <,=,> val following dir (-1,0,1)
* target/chosen exact value is <,=,> val following dir (-1,0,1)
*/
snd_pcm_uframes_t snd_pcm_hw_params_set_buffer_size_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_uframes_t val)
{
@ -4248,9 +4248,9 @@ int snd_pcm_hw_params_set_tick_time_minmax(snd_pcm_t *pcm, snd_pcm_hw_params_t *
* \param pcm PCM handle
* \param params Configuration space
* \param val approximate target tick duration in us
* \return approximate choosen tick duration in us
* \return approximate chosen tick duration in us
*
* target/choosen exact value is <,=,> val following dir (-1,0,1)
* target/chosen exact value is <,=,> val following dir (-1,0,1)
*/
unsigned int snd_pcm_hw_params_set_tick_time_near(snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val, int *dir)
{

4
src/pcm/pcm_adpcm.c
View file

@ -40,7 +40,7 @@ is being recommended by the IMA Digital Audio Technical Working Group.
The algorithm for this coder was taken from:
Proposal for Standardized Audio Interstreamge Formats,
IMA compatability project proceedings, Vol 2, Issue 2, May 1992.
IMA compatibility project proceedings, Vol 2, Issue 2, May 1992.
- No, this is *not* a G.721 coder/decoder. The algorithm used by G.721
is very complicated, requiring oodles of floating-point ops per
@ -127,7 +127,7 @@ static char adpcm_encoder(int sl, snd_pcm_adpcm_state_t * state)
*
* But in shift step bits are dropped. The net result of this is
* that even if you have fast mul/div hardware you cannot put it to
* good use since the fixup would be too expensive.
* good use since the fix-up would be too expensive.
*/
step = StepSize[state->step_idx];

4
src/pcm/pcm_misc.c
View file

@ -444,7 +444,7 @@ u_int8_t snd_pcm_format_silence(snd_pcm_format_t format)
}
/**
* \brief Silence a PCM samples buufer
* \brief Silence a PCM samples buffer
* \param format Sample format
* \param data Buffer
* \return samples Samples count
@ -516,7 +516,7 @@ static int linear_formats[4*2*2] = {
* \brief Compose a PCM sample linear format
* \param width Nominal bits per sample
* \param unsignd Sign: 0 signed, 1 unsigned
* \return big_endian Endianness: 0 little endian, 1 big endian
* \return big_endian Endian: 0 little endian, 1 big endian
*/
snd_pcm_format_t snd_pcm_build_linear_format(int width, int unsignd, int big_endian)
{

24
src/pcm/pcm_mmap.c
View file

@ -146,12 +146,12 @@ static snd_pcm_sframes_t snd_pcm_mmap_read_areas(snd_pcm_t *pcm,
* \return a positive number of frames actually written otherwise a
* negative error code
* \retval -EBADFD PCM is not in the right state (#SND_PCM_STATE_PREPARED or #SND_PCM_STATE_RUNNING)
* \retval -EPIPE an underrun occured
* \retval -ESTRPIPE a suspend event occured (stream is suspended and waiting for an application recovery)
* \retval -EPIPE an underrun occurred
* \retval -ESTRPIPE a suspend event occurred (stream is suspended and waiting for an application recovery)
*
* If the blocking behaviour is selected, then routine waits until
* all requested bytes are played or put to the playback ring buffer.
* The count of bytes can be less only if a signal or underrun occured.
* The count of bytes can be less only if a signal or underrun occurred.
*
* If the non-blocking behaviour is selected, then routine doesn't wait at all.
*/
@ -171,12 +171,12 @@ snd_pcm_sframes_t snd_pcm_mmap_writei(snd_pcm_t *pcm, const void *buffer, snd_pc
* \return a positive number of frames actually written otherwise a
* negative error code
* \retval -EBADFD PCM is not in the right state (#SND_PCM_STATE_PREPARED or #SND_PCM_STATE_RUNNING)
* \retval -EPIPE an underrun occured
* \retval -ESTRPIPE a suspend event occured (stream is suspended and waiting for an application recovery)
* \retval -EPIPE an underrun occurred
* \retval -ESTRPIPE a suspend event occurred (stream is suspended and waiting for an application recovery)
*
* If the blocking behaviour is selected, then routine waits until
* all requested bytes are played or put to the playback ring buffer.
* The count of bytes can be less only if a signal or underrun occured.
* The count of bytes can be less only if a signal or underrun occurred.
*
* If the non-blocking behaviour is selected, then routine doesn't wait at all.
*/
@ -196,12 +196,12 @@ snd_pcm_sframes_t snd_pcm_mmap_writen(snd_pcm_t *pcm, void **bufs, snd_pcm_ufram
* \return a positive number of frames actually read otherwise a
* negative error code
* \retval -EBADFD PCM is not in the right state (#SND_PCM_STATE_PREPARED or #SND_PCM_STATE_RUNNING)
* \retval -EPIPE an overrun occured
* \retval -ESTRPIPE a suspend event occured (stream is suspended and waiting for an application recovery)
* \retval -EPIPE an overrun occurred
* \retval -ESTRPIPE a suspend event occurred (stream is suspended and waiting for an application recovery)
*
* If the blocking behaviour was selected, then routine waits until
* all requested bytes are filled. The count of bytes can be less only
* if a signal or underrun occured.
* if a signal or underrun occurred.
*
* If the non-blocking behaviour is selected, then routine doesn't wait at all.
*/
@ -221,12 +221,12 @@ snd_pcm_sframes_t snd_pcm_mmap_readi(snd_pcm_t *pcm, void *buffer, snd_pcm_ufram
* \return a positive number of frames actually read otherwise a
* negative error code
* \retval -EBADFD PCM is not in the right state (#SND_PCM_STATE_PREPARED or #SND_PCM_STATE_RUNNING)
* \retval -EPIPE an overrun occured
* \retval -ESTRPIPE a suspend event occured (stream is suspended and waiting for an application recovery)
* \retval -EPIPE an overrun occurred
* \retval -ESTRPIPE a suspend event occurred (stream is suspended and waiting for an application recovery)
*
* If the blocking behaviour was selected, then routine waits until
* all requested bytes are filled. The count of bytes can be less only
* if a signal or underrun occured.
* if a signal or underrun occurred.
*
* If the non-blocking behaviour is selected, then routine doesn't wait at all.
*/

4
src/pcm/pcm_multi.c
View file

@ -230,7 +230,7 @@ static int snd_pcm_multi_hw_refine(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
for (k = 0; k < multi->slaves_count; ++k) {
err = snd_pcm_multi_hw_refine_sprepare(pcm, k, &sparams[k]);
if (err < 0) {
SNDERR("Slave PCM #%d not useable", k);
SNDERR("Slave PCM #%d not usable", k);
return err;
}
}
@ -828,7 +828,7 @@ int _snd_pcm_multi_open(snd_pcm_t **pcmp, const char *name,
channels_count = cchannel + 1;
}
if (channels_count == 0) {
SNDERR("No cannels defined");
SNDERR("No channels defined");
return -EINVAL;
}
slaves_id = calloc(slaves_count, sizeof(*slaves_id));

2
src/pcm/pcm_null.c
View file

@ -401,7 +401,7 @@ int snd_pcm_null_open(snd_pcm_t **pcmp, const char *name, snd_pcm_stream_t strea
This plugin discards contents of a PCM stream or creates a stream with zero
samples.
Note: This implementation uses devices /dev/null (playback, must be writeable)
Note: This implementation uses devices /dev/null (playback, must be writable)
and /dev/full (capture, must be readable).
\code

6
src/pcm/pcm_params.c
View file

@ -971,7 +971,7 @@ int snd_pcm_hw_param_never_eq(const snd_pcm_hw_params_t *params,
/* Choose one configuration from configuration space defined by PARAMS
The configuration choosen is that obtained fixing in this order:
The configuration chosen is that obtained fixing in this order:
first access
first format
first subformat
@ -2017,7 +2017,7 @@ int snd_pcm_hw_refine_slave(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
return err;
err = sprepare(pcm, &sparams);
if (err < 0) {
SNDERR("Slave PCM not useable");
SNDERR("Slave PCM not usable");
return err;
}
#ifdef RULES_DEBUG
@ -2148,7 +2148,7 @@ int snd_pcm_hw_refine(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
/* Install one of the configurations present in configuration
space defined by PARAMS.
The configuration choosen is that obtained fixing in this order:
The configuration chosen is that obtained fixing in this order:
first access
first format
first subformat

8
src/pcm/pcm_plug.c
View file

@ -627,7 +627,7 @@ static int snd_pcm_plug_hw_refine_schange(snd_pcm_t *pcm, snd_pcm_hw_params_t *p
}
if (snd_pcm_format_mask_empty(&sfmt_mask)) {
SNDERR("Unable to find an useable slave format for '%s'", pcm->name);
SNDERR("Unable to find an usable slave format for '%s'", pcm->name);
for (format = 0; format <= SND_PCM_FORMAT_LAST; format++) {
if (!snd_pcm_format_mask_test(format_mask, format))
continue;
@ -654,7 +654,7 @@ static int snd_pcm_plug_hw_refine_schange(snd_pcm_t *pcm, snd_pcm_hw_params_t *p
_snd_pcm_hw_param_set_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
&access_mask);
if (snd_pcm_access_mask_empty(snd_pcm_hw_param_get_mask(sparams, SND_PCM_HW_PARAM_ACCESS))) {
SNDERR("Unable to find an useable access for '%s'", pcm->name);
SNDERR("Unable to find an usable access for '%s'", pcm->name);
return -EINVAL;
}
}
@ -721,7 +721,7 @@ static int snd_pcm_plug_hw_refine_cchange(snd_pcm_t *pcm ATTRIBUTE_UNUSED,
}
if (snd_pcm_format_mask_empty(&fmt_mask)) {
SNDERR("Unable to find an useable client format");
SNDERR("Unable to find an usable client format");
for (format = 0; format <= SND_PCM_FORMAT_LAST; format++) {
if (!snd_pcm_format_mask_test(format_mask, format))
continue;
@ -971,7 +971,7 @@ pcm.name {
# copy: only first channels are copied to destination
# duplicate: duplicate first set of channels
# default: copy policy, except for mono capture - sum
ttable { # Transfer table (bidimensional compound of cchannels * schannels numbers)
ttable { # Transfer table (bi-dimensional compound of cchannels * schannels numbers)
CCHANNEL {
SCHANNEL REAL # route value (0.0 - 1.0)
}

2
src/rawmidi/rawmidi.c
View file

@ -91,7 +91,7 @@ defaults.rawmidi.card 0
defaults.rawmidi.device 0
defaults.rawmidi.subdevice -1
These defaults can be freely overwritten in local cofiguration files.
These defaults can be freely overwritten in local configuration files.
Example:

34
src/seq/seq.c
View file

@ -211,7 +211,7 @@ static int snd_seq_open_noupdate(snd_seq_t **seqp, snd_config_t *root,
* Creates a new handle and opens a connection to the kernel
* sequencer interface.
* After a client is created successfully, an event
* with #SND_SEQ_EVENT_CLIENT_START is broadcasted to announce port.
* with #SND_SEQ_EVENT_CLIENT_START is broadcast to announce port.
*/
int snd_seq_open(snd_seq_t **seqp, const char *name,
int streams, int mode)
@ -250,7 +250,7 @@ int snd_seq_open_lconf(snd_seq_t **seqp, const char *name,
*
* Closes the sequencer client and releases its resources.
* After a client is closed, an event with
* #SND_SEQ_EVENT_CLIENT_EXIT is broadcasted to announce port.
* #SND_SEQ_EVENT_CLIENT_EXIT is broadcast to announce port.
* The connection between other clients are disconnected.
* Call this just before exiting your program.
*/
@ -280,7 +280,7 @@ int snd_seq_close(snd_seq_t *seq)
* \return the number of poll descriptors.
*
* Get the number of poll descriptors. The polling events to be checked
* can be specifed by the second argument. When both input and output
* can be specified by the second argument. When both input and output
* are checked, pass \c POLLIN|POLLOUT
*/
int snd_seq_poll_descriptors_count(snd_seq_t *seq, short events)
@ -1160,7 +1160,7 @@ void snd_seq_port_info_set_synth_voices(snd_seq_port_info_t *info, int voices)
}
/**
* \brief Set the port-specifiied mode of a port_info container
* \brief Set the port-specified mode of a port_info container
* \param info port_info container
* \param val non-zero if specifying the port id at creation
*/
@ -1209,9 +1209,9 @@ void snd_seq_port_info_set_port_specified(snd_seq_port_info_t *info, int val)
* - #SND_SEQ_PORT_TYPE_SYNTH Synth device
* - #SND_SEQ_PORT_TYPE_DIRECT_SAMPLE Sampling device (supporting download)
* - #SND_SEQ_PORT_TYPE_SAMPLE Sampling device (sample can be downloaded at any time)
* - #SND_SEQ_PORT_TYPE_APPLICATION Application (suquencer/editor)
* - #SND_SEQ_PORT_TYPE_APPLICATION Application (sequencer/editor)
*
* A port may contain speicific midi channels, midi voices and synth voices.
* A port may contain specific midi channels, midi voices and synth voices.
* These values could be zero as default.
*/
int snd_seq_create_port(snd_seq_t *seq, snd_seq_port_info_t * port)
@ -1240,7 +1240,7 @@ int snd_seq_delete_port(snd_seq_t *seq, int port)
}
/**
* \brief obatin the information of a port on an arbitrary client
* \brief obtain the information of a port on an arbitrary client
* \param seq sequencer handle
* \param client client id to get
* \param port port id to get
@ -1257,7 +1257,7 @@ int snd_seq_get_any_port_info(snd_seq_t *seq, int client, int port, snd_seq_port
}
/**
* \brief obatin the information of a port on the current client
* \brief obtain the information of a port on the current client
* \param seq sequencer handle
* \param port port id to get
* \param info pointer information returns
@ -1641,7 +1641,7 @@ int snd_seq_query_subscribe_get_index(const snd_seq_query_subscribe_t *info)
}
/**
* \brief Get the number of subscriptiosn of a query_subscribe container
* \brief Get the number of subscriptions of a query_subscribe container
* \param info query_subscribe container
* \return number of subscriptions
*/
@ -1919,7 +1919,7 @@ void snd_seq_queue_info_set_locked(snd_seq_queue_info_t *info, int locked)
/**
* \brief Set the conditional bit flags of a queue_info container
* \param info queue_info container
* \param flags contidional bit flags
* \param flags conditional bit flags
*/
void snd_seq_queue_info_set_flags(snd_seq_queue_info_t *info, unsigned int flags)
{
@ -1946,7 +1946,7 @@ int snd_seq_create_queue(snd_seq_t *seq, snd_seq_queue_info_t *info)
}
/**
* \brief allocate a queue with the speicified name
* \brief allocate a queue with the specified name
* \param seq sequencer handle
* \param name the name of the new queue
* \return the queue id (zero or positive) on success otherwise a negative error code
@ -1972,7 +1972,7 @@ int snd_seq_alloc_queue(snd_seq_t *seq)
}
/**
* \breif delete the specified queue
* \brief delete the specified queue
* \param seq sequencer handle
* \param q queue id to delete
* \return 0 on success otherwise a negative error code
@ -2597,7 +2597,7 @@ int snd_seq_event_output(snd_seq_t *seq, snd_seq_event_t *ev)
/**
* \brief output an event onto the lib buffer without draining buffer
* \param seq sequencer handle
* \param ev event ot be output
* \param ev event to be output
* \return the byte size of remaining events. \c -EAGAIN if the buffer becomes full.
*
* This function doesn't drain buffer unlike snd_seq_event_output().
@ -2796,10 +2796,10 @@ static int snd_seq_event_retrieve_buffer(snd_seq_t *seq, snd_seq_event_t **retp)
* The event is created via snd_seq_create_event(), and its pointer is stored on
* ev argument.
*
* This function firstly recives the event byte-stream data from sequencer
* This function firstly receives the event byte-stream data from sequencer
* as much as possible at once. Then it retrieves the first event record
* and store the pointer on ev.
* By calling this function succeedingly, events are extract from the input buffer.
* By calling this function sequentially, events are extracted from the input buffer.
*
* If there is no input from sequencer, function falls into sleep
* in blocking mode until an event is received,
@ -2857,7 +2857,7 @@ static int snd_seq_event_input_feed(snd_seq_t *seq, int timeout)
* When events exist, they are transferred to the input buffer,
* and the number of received events are returned.
* If fetch_sequencer argument is zero and
* no events remain on the input buffer, function simplly returns zero.
* no events remain on the input buffer, function simply returns zero.
*/
int snd_seq_event_input_pending(snd_seq_t *seq, int fetch_sequencer)
{
@ -3635,7 +3635,7 @@ int snd_instr_header_get_follow_alias(const snd_instr_header_t *info)
/**
* \brief Set the instrument id of an instr_header container
* \param info instr_header container
* \param id instrumen id pointer
* \param id instrument id pointer
*/
void snd_instr_header_set_id(snd_instr_header_t *info, const snd_seq_instr_t *id)
{

6
src/seq/seqmid.c
View file

@ -41,7 +41,7 @@
* To send at scheduled time, set the schedule in \a ev.
* If \a ev is NULL, the event is composed locally and sent immediately
* to the specified queue. In any cases, you need to call #snd_seq_drain_event
* apropriately to feed the event.
* appropriately to feed the event.
*/
int snd_seq_control_queue(snd_seq_t *seq, int q, int type, int value, snd_seq_event_t *ev)
{
@ -92,7 +92,7 @@ int snd_seq_create_simple_port(snd_seq_t *seq, const char *name,
* \brief delete the port
* \param seq sequencer handle
* \param port port id
* \return 0 on success or negavie error code
* \return 0 on success or negative error code
*/
int snd_seq_delete_simple_port(snd_seq_t *seq, int port)
{
@ -124,7 +124,7 @@ int snd_seq_connect_from(snd_seq_t *seq, int myport, int src_client, int src_por
}
/**
* \brief sipmle subscription (w/o exclusive & time conversion)
* \brief simple subscription (w/o exclusive & time conversion)
* \param myport the port id as sender
* \param dest_client destination client id
* \param dest_port destination port id

10
test/latency.c
View file

@ -3,7 +3,7 @@
*
* Author: Jaroslav Kysela <perex@suse.cz>
*
* Author of bandpass filtersweep effect:
* Author of bandpass filter sweep effect:
* Maarten de Boer <mdeboer@iua.upf.es>
*
* This small demo program can be used for measuring latency between
@ -383,7 +383,7 @@ long writebuf(snd_pcm_t *handle, char *buf, long len, size_t *frames)
#define FILTERSWEEP_LFO_FREQ 0.2
#define FILTER_BANDWIDTH 50
/* filter sweep variables */
/* filter the sweep variables */
float lfo,dlfo,fs,fc,BW,C,D,a0,a1,a2,b1,b2,*x[3],*y[3];
void applyeffect(char* buffer,int r)
@ -439,7 +439,7 @@ Usage: latency [OPTION]... [FILE]...
-b,--block block mode
-t,--time maximal tick time in us
-p,--poll use poll (wait for event - reduces CPU usage)
-e,--effect apply an effect (bandpass filtersweep)
-e,--effect apply an effect (bandpass filter sweep)
");
printf("Recognized sample formats are:");
for (k = 0; k < SND_PCM_FORMAT_LAST; ++(unsigned long) k) {
@ -449,7 +449,7 @@ Usage: latency [OPTION]... [FILE]...
}
printf("\n\n");
printf("\
Tip #1 (useable latency with large periods, non-blocking mode, good CPU usage,
Tip #1 (usable latency with large periods, non-blocking mode, good CPU usage,
superb xrun prevention):
latency -m 8192 -M 8192 -t 1 -p
Tip #2 (superb latency, non-blocking mode, but heavy CPU usage):
@ -576,7 +576,7 @@ int main(int argc, char *argv[])
return 0;
}
/* initialize filter sweep variables */
/* initialize the filter sweep variables */
if (effect) {
fs = (float) rate;
BW = FILTER_BANDWIDTH;

12
test/midifile.3
View file

@ -66,7 +66,7 @@ unsigned int tempo;
.fi
.SH DESCRIPTION
The \fCmfread\fR function reads and inteprets a standard MIDI file.
The \fCmfread\fR function reads and interprets a standard MIDI file.
To use it you need to understand the general form of a
MIDI file and the type of information it contains, but you don't
need to know much, if anything, about the detailed format of the file
@ -180,14 +180,14 @@ types:
0x05 Lyric
0x06 Marker
0x07 Cue Point
0x08-0x0F Reserverd but Undefined
0x08-0x0F Reserved but Undefined
.fi
.in -1i
\fCMf_text\fR is called for each of these; the arguments are
the type number, the message length, and a pointer to the message buffer.
Misceallaneous \fImeta\fR messages are handled by \fCMf_metamisc\fR,
Miscellaneous \fImeta\fR messages are handled by \fCMf_metamisc\fR,
sequencer-specific messages are handled by \fCMf_seqspecific\fR, and
arbitrary "escape" messages (started with 0xF7) are handled by
\fCMf_arbitrary\fR.
@ -243,7 +243,7 @@ access your MIDI data structure, which can make use of other library
routines to write the actual MIDI data. The routine
\fCMf_writetrack\fR will be passed a single parameter which is the
number of the track to be written. The pointer \fCMf_putc\fR should be
set to point to a routine that accepts a charcter as input, writes that
set to point to a routine that accepts a character as input, writes that
character to a file, and returns the value that was written. In the
case of a format 1 file, a routine has to be written to write a tempo
map, and assigned to the function pointer \fCMf_writetempotrack\fR.
@ -268,7 +268,7 @@ whether bit 15 is set or not. If bit 15 of division is zero,
bits 14 through 0 represent the number of delta-time "ticks"
which make up a quarter note. If bit 15 of division is a one,
delta-times in a file correspond to subdivisions of a second
similiar to SMPTE and MIDI time code. In this format bits
similar to SMPTE and MIDI time code. In this format bits
14 through 8 contain one of four values - 24, -25, -29, or -30,
corresponding to the four standard SMPTE and MIDI time code
frame per second formats, where -29 represents 30 drop frame.
@ -279,7 +279,7 @@ the the resolution within a frame. Refer the Standard MIDI Files
.SH WRITING EXAMPLE
The following is a simple program to demonstrate writing MIDI files.
The track would consist of a series of quarter notes from lowest to
highest in pitch at constant velocity, each separted by a quarter-note
highest in pitch at constant velocity, each separated by a quarter-note
rest.
.sp
.in +1i

10
test/midifile.c
View file

@ -10,7 +10,7 @@
* The file format implemented here is called
* Standard MIDI Files, and is part of the Musical
* instrument Digital Interface specification.
* The spec is avaiable from:
* The spec is available from:
*
* International MIDI Association
* 5316 West 57th Street
@ -24,7 +24,7 @@
* (1) can now set the global variable Mf_interactive to 1 to prevent the
* reading functions from looking for file and track headers
* (2) can now write system exclusive data with
* mf_write_midi_event(delta_time, system_exlusive, 0, data, size)
* mf_write_midi_event(delta_time, system_exclusive, 0, data, size)
* (3) changed definition of 'sequencer_specific' in midifile.h to 0x7f
* (4) changed mf_write_tempo to take additional delta_time as first argument
* (since delta need not be zero)
@ -39,7 +39,7 @@
* because Mf_currtime does not really measure time at all, since
* its units change value at every tempo change. Mf_realtime is
* the midi-time elapsed in units of 1/16 of a centisecond (but it
* does not handle smpte times)
* does not handle SMPTE times)
* (9) maintains a history of tempo settings to update Mf_currtempo,
* to handle tempo tracks.
* (10) if there is an Mf_error function, the error routine no longer
@ -777,7 +777,7 @@ biggermsg ()
static int laststatus = 0;
/*
* mfwrite() - The only fuction you'll need to call to write out
* mfwrite() - The only function you'll need to call to write out
* a midi file.
*
* format 0 - Single multi-channel track
@ -791,7 +791,7 @@ static int laststatus = 0;
* bits 14 through 0 represent the number of delta-time
* "ticks" which make up a quarter note. If bit 15 of
* division is a one, delta-times in a file correspond to
* subdivisions of a second similiar to SMPTE and MIDI
* subdivisions of a second similar to SMPTE and MIDI
* time code. In this format bits 14 through 8 contain
* one of four values - 24, -25, -29, or -30,
* corresponding to the four standard SMPTE and MIDI

2
test/midifile.h
View file

@ -64,7 +64,7 @@ extern void mferror(char *s);
/* 7 bit controllers */
#define damper_pedal 0x40
#define portamento 0x41
#define sostenuto 0x42
#define sustenuto 0x42
#define soft_pedal 0x43
#define general_4 0x44
#define hold_2 0x45

30
test/pcm.c
View file

@ -1,5 +1,5 @@
/*
* This small demo generates simple sinus wave on output of speakers.
* This small demo sends a simple sinusoidal wave to your speakers.
*/
#include <stdio.h>
@ -18,7 +18,7 @@ int rate = 44100; /* stream rate */
int channels = 1; /* count of channels */
int buffer_time = 500000; /* ring buffer length in us */
int period_time = 100000; /* period time in us */
double freq = 440; /* sinus wave frequency in Hz */
double freq = 440; /* sinusoidal wave frequency in Hz */
snd_pcm_sframes_t buffer_size;
snd_pcm_sframes_t period_size;
@ -105,14 +105,14 @@ static int set_hwparams(snd_pcm_t *handle,
printf("Rate doesn't match (requested %iHz, get %iHz)\n", rate, err);
return -EINVAL;
}
/* set buffer time */
/* set the buffer time */
err = snd_pcm_hw_params_set_buffer_time_near(handle, params, buffer_time, &dir);
if (err < 0) {
printf("Unable to set buffer time %i for playback: %s\n", buffer_time, snd_strerror(err));
return err;
}
buffer_size = snd_pcm_hw_params_get_buffer_size(params);
/* set period time */
/* set the period time */
err = snd_pcm_hw_params_set_period_time_near(handle, params, period_time, &dir);
if (err < 0) {
printf("Unable to set period time %i for playback: %s\n", period_time, snd_strerror(err));
@ -132,31 +132,31 @@ static int set_swparams(snd_pcm_t *handle, snd_pcm_sw_params_t *swparams)
{
int err;
/* get current swparams */
/* get the current swparams */
err = snd_pcm_sw_params_current(handle, swparams);
if (err < 0) {
printf("Unable to determine current swparams for playback: %s\n", snd_strerror(err));
return err;
}
/* start transfer when the buffer is full */
/* start the transfer when the buffer is full */
err = snd_pcm_sw_params_set_start_threshold(handle, swparams, buffer_size);
if (err < 0) {
printf("Unable to set start threshold mode for playback: %s\n", snd_strerror(err));
return err;
}
/* allow transfer when at least period_size samples can be processed */
/* allow the transfer when at least period_size samples can be processed */
err = snd_pcm_sw_params_set_avail_min(handle, swparams, period_size);
if (err < 0) {
printf("Unable to set avail min for playback: %s\n", snd_strerror(err));
return err;
}
/* align all transfers to 1 samples */
/* align all transfers to 1 sample */
err = snd_pcm_sw_params_set_xfer_align(handle, swparams, 1);
if (err < 0) {
printf("Unable to set transfer align for playback: %s\n", snd_strerror(err));
return err;
}
/* write the parameters to device */
/* write the parameters to the playback device */
err = snd_pcm_sw_params(handle, swparams);
if (err < 0) {
printf("Unable to set sw params for playback: %s\n", snd_strerror(err));
@ -171,14 +171,14 @@ static int set_swparams(snd_pcm_t *handle, snd_pcm_sw_params_t *swparams)
static int xrun_recovery(snd_pcm_t *handle, int err)
{
if (err == -EPIPE) { /* underrun */
if (err == -EPIPE) { /* under-run */
err = snd_pcm_prepare(handle);
if (err < 0)
printf("Can't recovery from underrun, prepare failed: %s\n", snd_strerror(err));
return 0;
} else if (err == -ESTRPIPE) {
while ((err = snd_pcm_resume(handle)) == -EAGAIN)
sleep(1); /* wait until suspend flag is released */
sleep(1); /* wait until the suspend flag is released */
if (err < 0) {
err = snd_pcm_prepare(handle);
if (err < 0)
@ -304,8 +304,8 @@ static int write_and_poll_loop(snd_pcm_t *handle,
cptr -= err;
if (cptr == 0)
break;
/* it is possible, that initial buffer cannot store */
/* all data from last period, so wait awhile */
/* it is possible, that the initial buffer cannot store */
/* all data from the last period, so wait awhile */
err = wait_for_poll(handle, ufds, count);
if (err < 0) {
if (snd_pcm_state(handle) == SND_PCM_STATE_XRUN ||
@ -554,7 +554,7 @@ Usage: latency [OPTION]... [FILE]...
-f,--frequency sine wave frequency in Hz
-b,--buffer ring buffer size in samples
-p,--period period size in us
-m,--method tranfer method
-m,--method transfer method
");
printf("Recognized sample formats are:");
@ -564,7 +564,7 @@ Usage: latency [OPTION]... [FILE]...
printf(" %s", s);
}
printf("\n");
printf("Recognized tranfer methods are:");
printf("Recognized transfer methods are:");
for (k = 0; transfer_methods[k].name; k++)
printf(" %s", transfer_methods[k].name);
printf("\n");

68
test/playmidi1.c
View file

@ -48,10 +48,10 @@
#include "../include/asoundlib.h"
/* send real-time time stamps instead of midi ticks to the ALSA sequencer */
/* send the real-time time stamps (instead of midi ticks) to the ALSA sequencer */
static int use_realtime = 0;
/* control event buffering by blocking mode */
/* control the event buffering by using a blocking mode */
static int use_blocking_mode = 1;
/* default destination queue, client and port numbers */
@ -61,7 +61,7 @@ static int use_blocking_mode = 1;
/* event pool size */
#define WRITE_POOL_SIZE 200
#define WRITE_POOL_SPACE 10
#define READ_POOL_SIZE 10 /* we need read pool only for echoing */
#define READ_POOL_SIZE 10 /* we need to read the pool only for echoing */
static FILE *F;
static snd_seq_t *seq_handle = NULL;
@ -126,13 +126,13 @@ static void write_ev(snd_seq_event_t *ev)
}
}
/* read byte */
/* read the byte */
static int mygetc(void)
{
return getc(F);
}
/* print out text */
/* print out the text */
static void mytext(int type ATTRIBUTE_UNUSED, int leng, char *msg)
{
char *p;
@ -159,9 +159,9 @@ static void do_header(int format, int ntracks, int division)
alsa_stop_timer();
exit(1);
}
/* set ppq */
/* set the ppq */
snd_seq_queue_tempo_alloca(&tempo);
/* ppq must be set before starting timer */
/* ppq must be set before starting the timer */
if (snd_seq_get_queue_tempo(seq_handle, dest_queue, tempo) < 0) {
perror("get_queue_tempo");
exit(1);
@ -199,7 +199,7 @@ static void do_header(int format, int ntracks, int division)
}
}
/* fill time */
/* fill the event time */
static void set_event_time(snd_seq_event_t *ev, unsigned int currtime)
{
if (use_realtime) {
@ -216,7 +216,7 @@ static void set_event_time(snd_seq_event_t *ev, unsigned int currtime)
}
}
/* fill normal event header */
/* fill the normal event header */
static void set_event_header(snd_seq_event_t *ev)
{
snd_seq_ev_clear(ev);
@ -225,13 +225,13 @@ static void set_event_header(snd_seq_event_t *ev)
set_event_time(ev, Mf_currtime);
}
/* start timer */
/* start the timer */
static void alsa_start_timer(void)
{
snd_seq_start_queue(seq_handle, dest_queue, NULL);
}
/* stop timer */
/* stop the timer */
static void alsa_stop_timer(void)
{
snd_seq_event_t ev;
@ -239,7 +239,7 @@ static void alsa_stop_timer(void)
snd_seq_stop_queue(seq_handle, dest_queue, &ev);
}
/* change tempo */
/* change the tempo */
static void do_tempo(int us)
{
snd_seq_event_t ev;
@ -250,7 +250,7 @@ static void do_tempo(int us)
printf("Tempo %d us/beat, %.2f bpm\n", us, bpm);
}
/* store new tempo and timestamp of tempo change */
/* store the new tempo and timestamp of the tempo change */
local_secs = tick2time_dbl(Mf_currtime);
local_ticks = Mf_currtime;
local_tempo = us;
@ -309,7 +309,7 @@ static void do_parameter(int chan, int control, int value)
static void do_pitchbend(int chan, int lsb, int msb)
{ /* !@#$% lsb & msb are in wrong order in docs */
{ /* !@#$% lsb & msb are in the wrong order in docs */
snd_seq_event_t ev;
if (verbose >= VERB_EVENT)
@ -368,10 +368,10 @@ static snd_seq_event_t *wait_for_event(void)
snd_seq_event_t *input_event;
if (use_blocking_mode) {
/* read event - blocked until any event is read */
/* read the event - blocked until any event is read */
left = snd_seq_event_input(seq_handle, &input_event);
} else {
/* read event - using select syscall */
/* read the event - using select syscall */
while ((left = snd_seq_event_input(seq_handle, &input_event)) >= 0 &&
input_event == NULL) {
int npfds = snd_seq_poll_descriptors_count(seq_handle, POLLIN);
@ -392,13 +392,13 @@ static snd_seq_event_t *wait_for_event(void)
return input_event;
}
/* synchronize to the end of event */
/* synchronize to the end of the event */
static void alsa_sync(void)
{
/* send echo event to self client. */
/* send the echo event to the self client. */
if (verbose >= VERB_MUCH)
printf("alsa_sync syncing...\n");
/* dump buffer */
/* dump the buffer */
snd_seq_drain_output(seq_handle);
snd_seq_sync_output_queue(seq_handle);
if (verbose >= VERB_MUCH)
@ -407,12 +407,12 @@ static void alsa_sync(void)
}
/* wait for start of the queue */
/* wait for the start of the queue */
static void wait_start(void)
{
snd_seq_event_t *input_event;
/* wait the start event from the system timer */
/* wait for the start event from the system timer */
for (;;) {
input_event = wait_for_event();
if (input_event) {
@ -432,7 +432,7 @@ static void wait_start(void)
}
/* print usage */
/* print the usage */
static void usage(void)
{
fprintf(stderr, "usage: playmidi1 [options] [file]\n");
@ -441,7 +441,7 @@ static void usage(void)
fprintf(stderr, " -a client:port : set destination address (default=%d:%d)\n",
DEST_CLIENT_NUMBER, DEST_PORT_NUMBER);
fprintf(stderr, " -q queue: use the specified queue\n");
fprintf(stderr, " -s queue: slave mode (allow external clock synchronisation)\n");
fprintf(stderr, " -s queue: slave mode (allow external clock synchronization)\n");
fprintf(stderr, " -r : play on real-time mode\n");
fprintf(stderr, " -b : play on non-blocking mode\n");
}
@ -496,8 +496,8 @@ int main(int argc, char *argv[])
printf("ALSA MIDI Player, feeding events to song queue\n");
}
/* open sequencer device */
/* Here we open the device read/write for slave mode. */
/* open the sequencer device */
/* Here we open the device in read/write for slave mode. */
tmp = snd_seq_open(&seq_handle, "hw", slave ? SND_SEQ_OPEN_DUPLEX : SND_SEQ_OPEN_OUTPUT, 0);
if (tmp < 0) {
perror("open /dev/snd/seq");
@ -510,20 +510,20 @@ int main(int argc, char *argv[])
exit(1);
}
/* set name */
/* set event filter to recieve only echo event */
/* if running in slave mode also listen for START event */
/* set the name */
/* set the event filter to receive only the echo event */
/* if running in slave mode, also listen for a START event */
if (slave)
snd_seq_set_client_event_filter(seq_handle, SND_SEQ_EVENT_START);
snd_seq_set_client_name(seq_handle, "MIDI file player");
/* create port */
/* create the port */
my_port = snd_seq_create_simple_port(seq_handle, "Port 0",
SND_SEQ_PORT_CAP_WRITE |
SND_SEQ_PORT_CAP_READ,
SND_SEQ_PORT_TYPE_MIDI_GENERIC);
if (my_port < 0) {
perror("creat port");
perror("create port");
exit(1);
}
@ -534,7 +534,7 @@ int main(int argc, char *argv[])
dest_client = dest_addr.client;
dest_port = dest_addr.port;
/* setup queue */
/* set the queue */
if (dest_queue >= 0) {
shared_queue = 1;
if (snd_seq_set_queue_usage(seq_handle, dest_queue, 1) < 0) {
@ -550,14 +550,14 @@ int main(int argc, char *argv[])
}
}
/* setup subscriber */
/* set the subscriber */
tmp = snd_seq_connect_to(seq_handle, my_port, dest_client, dest_port);
if (tmp < 0) {
perror("subscribe");
exit(1);
}
/* subscribe for timer START event */
/* subscribe for the timer START event */
if (slave) {
tmp = snd_seq_connect_from(seq_handle, my_port,
SND_SEQ_CLIENT_SYSTEM,
@ -568,7 +568,7 @@ int main(int argc, char *argv[])
}
}
/* change pool size */
/* change the pool size */
if (snd_seq_set_client_pool_output(seq_handle, WRITE_POOL_SIZE) < 0 ||
snd_seq_set_client_pool_input(seq_handle, READ_POOL_SIZE) < 0 ||
snd_seq_set_client_pool_output_room(seq_handle, WRITE_POOL_SPACE) < 0) {

2
test/rawmidi.c
View file

@ -17,7 +17,7 @@ static void usage(void)
fprintf(stderr, " example:\n");
fprintf(stderr, " rawmidi -i hw:0,0 -o /dev/midi1\n");
fprintf(stderr, " tests input for card 0, device 0, using snd_rawmidi API\n");
fprintf(stderr, " and /dev/midi1 using file desciptors\n");
fprintf(stderr, " and /dev/midi1 using file descriptors\n");
}
int stop=0;

2
test/seq-decoder.c
View file

@ -126,7 +126,7 @@ int decode_event(snd_seq_event_t * ev)
printf("%sEvent = %s", space, event_names[ev->type]);
else
printf("%sEvent = Reserved %d\n", space, ev->type);
/* decode actual event data... */
/* decode the actual event data... */
switch (ev->type) {
case SND_SEQ_EVENT_NOTE:
printf("; ch=%d, note=%d, velocity=%d, off_velocity=%d, duration=%d\n",

2
test/seq-sender.c
View file

@ -80,7 +80,7 @@ void event_sender_start_timer(snd_seq_t *handle, int client, int queue, snd_pcm_
}
bzero(&qtimer, sizeof(qtimer));
qtimer.type = SND_SEQ_TIMER_MASTER;
/* note: last bit from subdevices specifies playback */
/* note: last bit from the subdevices specifies playback */
/* or capture direction for the timer specification */
qtimer.number = SND_TIMER_PCM(pcard, pdevice, pinfo.subdevice << 1);
if ((err = snd_seq_set_queue_timer(handle, queue, &qtimer)) < 0) {