mirrors/alsa-lib
1
0
Fork 0
mirror of https://github.com/alsa-project/alsa-lib.git synced 2025-11-10 13:30:01 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

huge correction of tabulators and whitespaces

Browse source 
Signed-off-by: Jaroslav Kysela <perex@perex.cz>
This commit is contained in:
Jaroslav Kysela 2025-11-07 14:27:38 +01:00
parent b37ac0982b
commit 66a3d542ac
157 changed files with 2008 additions and 2008 deletions
Download patch file Download diff file Expand all files Collapse all files

4
include/alsa-symbols.h
View file

@ -56,8 +56,8 @@
#define use_symbol_version(real, name, version) /* nothing */
#if defined(__alpha__) || defined(__mips__)
#define use_default_symbol_version(real, name, version) \
__asm__ (".weak " ASM_NAME(#name)); \
__asm__ (ASM_NAME(#name) " = " ASM_NAME(#real))
__asm__ (".weak " ASM_NAME(#name)); \
__asm__ (ASM_NAME(#name) " = " ASM_NAME(#real))
#else
#define use_default_symbol_version(real, name, version) \
__asm__ (".weak " ASM_NAME(#name)); \

12
include/conf.h
View file

@ -52,15 +52,15 @@ extern "C" {
/** \brief Configuration node type. */
typedef enum _snd_config_type {
/** Integer number. */
SND_CONFIG_TYPE_INTEGER,
SND_CONFIG_TYPE_INTEGER,
/** 64-bit integer number. */
SND_CONFIG_TYPE_INTEGER64,
SND_CONFIG_TYPE_INTEGER64,
/** Real number. */
SND_CONFIG_TYPE_REAL,
SND_CONFIG_TYPE_REAL,
/** Character string. */
SND_CONFIG_TYPE_STRING,
/** Pointer (runtime only, cannot be saved). */
SND_CONFIG_TYPE_POINTER,
SND_CONFIG_TYPE_STRING,
/** Pointer (runtime only, cannot be saved). */
SND_CONFIG_TYPE_POINTER,
/** Compound node. */
SND_CONFIG_TYPE_COMPOUND = 1024
} snd_config_type_t;

2
include/local.h
View file

@ -385,7 +385,7 @@ int snd_config_check_hop(snd_config_t *conf);
#define SND_CONF_MAX_HOPS 64
int snd_config_search_alias_hooks(snd_config_t *config,
const char *base, const char *key,
const char *base, const char *key,
snd_config_t **result);
int _snd_conf_generic_id(const char *id);

18
include/pcm.h
View file

@ -679,15 +679,15 @@ snd_pcm_chmap_t *snd_pcm_chmap_parse_string(const char *str);
int snd_pcm_recover(snd_pcm_t *pcm, int err, int silent);
int snd_pcm_set_params(snd_pcm_t *pcm,
snd_pcm_format_t format,
snd_pcm_access_t access,
unsigned int channels,
unsigned int rate,
int soft_resample,
unsigned int latency);
snd_pcm_format_t format,
snd_pcm_access_t access,
unsigned int channels,
unsigned int rate,
int soft_resample,
unsigned int latency);
int snd_pcm_get_params(snd_pcm_t *pcm,
snd_pcm_uframes_t *buffer_size,
snd_pcm_uframes_t *period_size);
snd_pcm_uframes_t *buffer_size,
snd_pcm_uframes_t *period_size);
/** \} */
@ -1326,7 +1326,7 @@ int16_t *snd_pcm_scope_s16_get_channel_buffer(snd_pcm_scope_t *scope,
/** Simple PCM latency type */
typedef enum _snd_spcm_latency {
/** standard latency - for standard playback or capture
(estimated latency in one direction 350ms) */
(estimated latency in one direction 350ms) */
SND_SPCM_LATENCY_STANDARD = 0,
/** medium latency - software phones etc.
(estimated latency in one direction maximally 25ms */

8
include/pcm_plugin.h
View file

@ -81,7 +81,7 @@ int snd_pcm_copy_open(snd_pcm_t **pcmp, const char *name,
snd_pcm_t *slave, int close_slave);
int _snd_pcm_copy_open(snd_pcm_t **pcmp, const char *name,
snd_config_t *root, snd_config_t *conf,
snd_pcm_stream_t stream, int mode);
snd_pcm_stream_t stream, int mode);
/*
* Linear conversion plugin
@ -111,7 +111,7 @@ int snd_pcm_mulaw_open(snd_pcm_t **pcmp, const char *name,
int close_slave);
int _snd_pcm_mulaw_open(snd_pcm_t **pcmp, const char *name,
snd_config_t *root, snd_config_t *conf,
snd_pcm_stream_t stream, int mode);
snd_pcm_stream_t stream, int mode);
/*
* Linear<->a-Law conversion plugin
@ -207,8 +207,8 @@ int snd_pcm_jack_open(snd_pcm_t **pcmp, const char *name,
snd_config_t *capture_conf,
snd_pcm_stream_t stream, int mode);
int _snd_pcm_jack_open(snd_pcm_t **pcmp, const char *name,
snd_config_t *root, snd_config_t *conf,
snd_pcm_stream_t stream, int mode);
snd_config_t *root, snd_config_t *conf,
snd_pcm_stream_t stream, int mode);
/** \} */

2
include/sound/uapi/asound.h
View file

@ -409,7 +409,7 @@ struct snd_pcm_hw_params {
SNDRV_PCM_HW_PARAM_FIRST_MASK + 1];
struct snd_mask mres[5]; /* reserved masks */
struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL -
SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1];
SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1];
struct snd_interval ires[9]; /* reserved intervals */
unsigned int rmask; /* W: requested masks */
unsigned int cmask; /* R: changed masks */

2
include/timer.h
View file

@ -105,7 +105,7 @@ typedef enum _snd_timer_event {
/** timer read structure */
typedef struct _snd_timer_read {
unsigned int resolution; /**< tick resolution in nanoseconds */
unsigned int ticks; /**< count of happened ticks */
unsigned int ticks; /**< count of happened ticks */
} snd_timer_read_t;
/** timer tstamp + event read structure */

14
include/use-case.h
View file

@ -239,8 +239,8 @@ int snd_use_case_free_list(const char *list[], int items);
*
*/
int snd_use_case_get_list(snd_use_case_mgr_t *uc_mgr,
const char *identifier,
const char **list[]);
const char *identifier,
const char **list[]);
/**
@ -410,8 +410,8 @@ int snd_use_case_get_list(snd_use_case_mgr_t *uc_mgr,
* increase latency.
*/
int snd_use_case_get(snd_use_case_mgr_t *uc_mgr,
const char *identifier,
const char **value);
const char *identifier,
const char **value);
/**
* \brief Get current - integer
@ -456,8 +456,8 @@ int snd_use_case_geti(snd_use_case_mgr_t *uc_mgr,
* - check transmit sequence firstly
*/
int snd_use_case_set(snd_use_case_mgr_t *uc_mgr,
const char *identifier,
const char *value);
const char *identifier,
const char *value);
/**
* \brief Open and initialise use case core for sound card
@ -482,7 +482,7 @@ int snd_use_case_set(snd_use_case_mgr_t *uc_mgr,
* only one ALSA sound card in this case.
*/
int snd_use_case_mgr_open(snd_use_case_mgr_t **uc_mgr,
const char *card_name);
const char *card_name);
/**

182
modules/mixer/simple/python.c
View file

@ -68,24 +68,24 @@ static PyInterpreterState *main_interpreter;
static inline int get_long(PyObject *o, long *val)
{
#if PY_MAJOR_VERSION < 3
if (PyInt_Check(o)) {
*val = PyInt_AsLong(o);
return 0;
}
if (PyInt_Check(o)) {
*val = PyInt_AsLong(o);
return 0;
}
#endif
if (PyLong_Check(o)) {
*val = PyLong_AsLong(o);
return 0;
}
return 1;
if (PyLong_Check(o)) {
*val = PyLong_AsLong(o);
return 0;
}
return 1;
}
static inline PyObject *InternFromString(const char *name)
{
#if PY_MAJOR_VERSION < 3
return PyString_InternFromString(name);
return PyString_InternFromString(name);
#else
return PyUnicode_InternFromString(name);
return PyUnicode_InternFromString(name);
#endif
}
@ -191,7 +191,7 @@ static int is_ops(snd_mixer_elem_t *elem, int dir, int cmd, int val)
}
static int get_x_range_ops(snd_mixer_elem_t *elem, int dir,
long *min, long *max, const char *attr)
long *min, long *max, const char *attr)
{
PyObject *obj1, *t1, *t2, *res;
struct pymelem *pymelem = melem_to_pymelem(elem);
@ -225,13 +225,13 @@ static int get_x_range_ops(snd_mixer_elem_t *elem, int dir,
}
static int get_range_ops(snd_mixer_elem_t *elem, int dir,
long *min, long *max)
long *min, long *max)
{
return get_x_range_ops(elem, dir, min, max, "opsGetRange");
}
static int set_range_ops(snd_mixer_elem_t *elem, int dir,
long min, long max)
long min, long max)
{
PyObject *obj1;
struct pymelem *pymelem = melem_to_pymelem(elem);
@ -244,8 +244,8 @@ static int set_range_ops(snd_mixer_elem_t *elem, int dir,
}
static int get_x_ops(snd_mixer_elem_t *elem, int dir,
long channel, long *value,
const char *attr)
long channel, long *value,
const char *attr)
{
PyObject *obj1, *t1, *res;
struct pymelem *pymelem = melem_to_pymelem(elem);
@ -283,7 +283,7 @@ static int get_volume_ops(snd_mixer_elem_t *elem, int dir,
}
static int get_switch_ops(snd_mixer_elem_t *elem, int dir,
snd_mixer_selem_channel_id_t channel, int *value)
snd_mixer_selem_channel_id_t channel, int *value)
{
long value1;
int res;
@ -337,21 +337,21 @@ static int ask_dB_vol_ops(snd_mixer_elem_t *elem,
}
static int get_dB_ops(snd_mixer_elem_t *elem,
int dir,
snd_mixer_selem_channel_id_t channel,
long *value)
int dir,
snd_mixer_selem_channel_id_t channel,
long *value)
{
return get_x_ops(elem, dir, channel, value, "opsGetDB");
}
static int get_dB_range_ops(snd_mixer_elem_t *elem, int dir,
long *min, long *max)
long *min, long *max)
{
return get_x_range_ops(elem, dir, min, max, "opsGetDBRange");
}
static int set_volume_ops(snd_mixer_elem_t *elem, int dir,
snd_mixer_selem_channel_id_t channel, long value)
snd_mixer_selem_channel_id_t channel, long value)
{
PyObject *obj1;
struct pymelem *pymelem = melem_to_pymelem(elem);
@ -364,7 +364,7 @@ static int set_volume_ops(snd_mixer_elem_t *elem, int dir,
}
static int set_switch_ops(snd_mixer_elem_t *elem, int dir,
snd_mixer_selem_channel_id_t channel, int value)
snd_mixer_selem_channel_id_t channel, int value)
{
PyObject *obj1;
struct pymelem *pymelem = melem_to_pymelem(elem);
@ -377,8 +377,8 @@ static int set_switch_ops(snd_mixer_elem_t *elem, int dir,
}
static int set_dB_ops(snd_mixer_elem_t *elem, int dir,
snd_mixer_selem_channel_id_t channel,
long db_gain, int xdir)
snd_mixer_selem_channel_id_t channel,
long db_gain, int xdir)
{
PyObject *obj1;
struct pymelem *pymelem = melem_to_pymelem(elem);
@ -392,8 +392,8 @@ static int set_dB_ops(snd_mixer_elem_t *elem, int dir,
}
static int enum_item_name_ops(snd_mixer_elem_t *elem,
unsigned int item,
size_t maxlen, char *buf)
unsigned int item,
size_t maxlen, char *buf)
{
PyObject *obj1, *obj2, *t1, *res;
struct pymelem *pymelem = melem_to_pymelem(elem);
@ -441,8 +441,8 @@ errlbl:
}
static int get_enum_item_ops(snd_mixer_elem_t *elem,
snd_mixer_selem_channel_id_t channel,
unsigned int *itemp)
snd_mixer_selem_channel_id_t channel,
unsigned int *itemp)
{
PyObject *obj1, *t1, *res;
struct pymelem *pymelem = melem_to_pymelem(elem);
@ -473,8 +473,8 @@ static int get_enum_item_ops(snd_mixer_elem_t *elem,
}
static int set_enum_item_ops(snd_mixer_elem_t *elem,
snd_mixer_selem_channel_id_t channel,
unsigned int item)
snd_mixer_selem_channel_id_t channel,
unsigned int item)
{
PyObject *obj1;
struct pymelem *pymelem = melem_to_pymelem(elem);
@ -486,21 +486,21 @@ static int set_enum_item_ops(snd_mixer_elem_t *elem,
}
static struct sm_elem_ops simple_python_ops = {
.is = is_ops,
.get_range = get_range_ops,
.get_dB_range = get_dB_range_ops,
.set_range = set_range_ops,
.ask_vol_dB = ask_vol_dB_ops,
.ask_dB_vol = ask_dB_vol_ops,
.get_volume = get_volume_ops,
.get_dB = get_dB_ops,
.set_volume = set_volume_ops,
.set_dB = set_dB_ops,
.get_switch = get_switch_ops,
.set_switch = set_switch_ops,
.enum_item_name = enum_item_name_ops,
.get_enum_item = get_enum_item_ops,
.set_enum_item = set_enum_item_ops
.is = is_ops,
.get_range = get_range_ops,
.get_dB_range = get_dB_range_ops,
.set_range = set_range_ops,
.ask_vol_dB = ask_vol_dB_ops,
.ask_dB_vol = ask_dB_vol_ops,
.get_volume = get_volume_ops,
.get_dB = get_dB_ops,
.set_volume = set_volume_ops,
.set_dB = set_dB_ops,
.get_switch = get_switch_ops,
.set_switch = set_switch_ops,
.enum_item_name = enum_item_name_ops,
.get_enum_item = get_enum_item_ops,
.set_enum_item = set_enum_item_ops
};
static void selem_free(snd_mixer_elem_t *elem)
@ -703,18 +703,18 @@ static PyMethodDef pymelem_methods[] = {
};
static PyTypeObject pymelem_type = {
PyVarObject_HEAD_INIT(NULL, 0)
tp_name: "smixer_python.InternalMElement",
tp_basicsize: sizeof(struct pymelem),
tp_dealloc: (destructor)pymelem_dealloc,
tp_flags: Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
tp_doc: NULL /* mixerinit__doc__ */,
tp_getset: pymelem_getseters,
tp_init: (initproc)pymelem_init,
tp_alloc: PyType_GenericAlloc,
tp_new: PyType_GenericNew,
tp_free: PyObject_Del,
tp_methods: pymelem_methods,
PyVarObject_HEAD_INIT(NULL, 0)
tp_name: "smixer_python.InternalMElement",
tp_basicsize: sizeof(struct pymelem),
tp_dealloc: (destructor)pymelem_dealloc,
tp_flags: Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
tp_doc: NULL /* mixerinit__doc__ */,
tp_getset: pymelem_getseters,
tp_init: (initproc)pymelem_init,
tp_alloc: PyType_GenericAlloc,
tp_new: PyType_GenericNew,
tp_free: PyObject_Del,
tp_methods: pymelem_methods,
};
static PyObject *
@ -884,18 +884,18 @@ static PyMethodDef pymixer_methods[] = {
};
static PyTypeObject pymixer_type = {
PyVarObject_HEAD_INIT(NULL, 0)
tp_name: "smixer_python.InternalMixer",
tp_basicsize: sizeof(struct pymixer),
tp_dealloc: (destructor)pymixer_dealloc,
tp_flags: Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
tp_doc: NULL /* mixerinit__doc__ */,
tp_getset: pymixer_getseters,
tp_init: (initproc)pymixer_init,
tp_alloc: PyType_GenericAlloc,
tp_new: PyType_GenericNew,
tp_free: PyObject_Del,
tp_methods: pymixer_methods,
PyVarObject_HEAD_INIT(NULL, 0)
tp_name: "smixer_python.InternalMixer",
tp_basicsize: sizeof(struct pymixer),
tp_dealloc: (destructor)pymixer_dealloc,
tp_flags: Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
tp_doc: NULL /* mixerinit__doc__ */,
tp_getset: pymixer_getseters,
tp_init: (initproc)pymixer_init,
tp_alloc: PyType_GenericAlloc,
tp_new: PyType_GenericNew,
tp_free: PyObject_Del,
tp_methods: pymixer_methods,
};
static PyMethodDef python_methods[] = {
@ -985,19 +985,19 @@ int alsa_mixer_simple_event(snd_mixer_class_t *class, unsigned int mask,
tstate = PyThreadState_New(main_interpreter);
PyThreadState_Swap(tstate);
t = PyTuple_New(3);
if (t) {
PyTuple_SET_ITEM(t, 0, (PyObject *)PyInt_FromLong(mask));
o = find_helem(priv, helem);
if (mask & SND_CTL_EVENT_MASK_ADD) {
if (o == NULL)
o = new_helem(priv, helem);
t = PyTuple_New(3);
if (t) {
PyTuple_SET_ITEM(t, 0, (PyObject *)PyInt_FromLong(mask));
o = find_helem(priv, helem);
if (mask & SND_CTL_EVENT_MASK_ADD) {
if (o == NULL)
o = new_helem(priv, helem);
}
if (o == NULL)
return 0;
if (o == NULL)
return 0;
PyTuple_SET_ITEM(t, 1, o);
Py_INCREF(o);
o = melem ? find_melem(priv, melem) : Py_None;
o = melem ? find_melem(priv, melem) : Py_None;
PyTuple_SET_ITEM(t, 2, o);
Py_INCREF(o);
r = PyObject_CallObject(priv->py_event_func, t);
@ -1039,8 +1039,8 @@ static void alsa_mixer_simple_free(snd_mixer_class_t *class)
}
static int alsa_mixer_simple_pyinit(struct python_priv *priv,
PyObject *py_mod,
FILE *fp,
PyObject *py_mod,
FILE *fp,
const char *file,
snd_mixer_class_t *class,
snd_mixer_t *mixer,
@ -1091,15 +1091,15 @@ static int alsa_mixer_simple_pyinit(struct python_priv *priv,
#if PY_MAJOR_VERSION >= 3
static struct PyModuleDef smixer_python_module = {
PyModuleDef_HEAD_INIT,
"smixer_python",
NULL,
0,
python_methods,
NULL,
NULL,
NULL,
NULL
PyModuleDef_HEAD_INIT,
"smixer_python",
NULL,
0,
python_methods,
NULL,
NULL,
NULL,
NULL
};
#endif

12
modules/mixer/simple/sbase.c
View file

@ -62,10 +62,10 @@ static long to_user(struct selem_base *s, int dir, struct helem_base *c, long va
static long from_user(struct selem_base *s, int dir, struct helem_base *c, long value)
{
int64_t n;
int64_t n;
if (s->dir[dir].max == s->dir[dir].min)
return c->min;
n = (int64_t) (value - s->dir[dir].min) * (c->max - c->min);
n = (int64_t) (value - s->dir[dir].min) * (c->max - c->min);
return c->min + (n + (s->dir[dir].max - s->dir[dir].min) / 2) / (s->dir[dir].max - s->dir[dir].min);
}
#endif
@ -374,7 +374,7 @@ static int simple_event_add1(snd_mixer_class_t *class,
case PURPOSE_SWITCH:
if (ctype != SND_CTL_ELEM_TYPE_BOOLEAN) {
__invalid_type:
snd_mixer_selem_id_free(id);
snd_mixer_selem_id_free(id);
free(hsimple);
return -EINVAL;
}
@ -446,9 +446,9 @@ static int simple_event_add1(snd_mixer_class_t *class,
err = snd_mixer_elem_value(melem);
return err;
__error:
if (new)
snd_mixer_elem_free(melem);
return -EINVAL;
if (new)
snd_mixer_elem_free(melem);
return -EINVAL;
}
static int simple_event_add(snd_mixer_class_t *class, snd_hctl_elem_t *helem)

4
modules/mixer/simple/sbasedl.c
View file

@ -97,8 +97,8 @@ int mixer_simple_basic_dlopen(snd_mixer_class_t *class,
return 1;
__error:
if (initflag)
free(priv);
if (initflag)
free(priv);
if (h)
snd_dlclose(h);
free(xlib);

28
src/conf.c
View file

@ -255,8 +255,8 @@ name [=] value [,|;]
# Compound assignment (first style)
name [=] {
name1 [=] value [,|;]
...
name1 [=] value [,|;]
...
}
# Compound assignment (second style)
@ -264,9 +264,9 @@ name.name1 [=] value [,|;]
# Array assignment (first style)
name [
value0 [,|;]
value1 [,|;]
...
value0 [,|;]
value1 [,|;]
...
]
# Array assignment (second style)
@ -1341,7 +1341,7 @@ static int parse_array_def(snd_config_t *parent, input_t *input, int *idx, int s
err = 0;
__end:
free(id);
return err;
return err;
}
static int parse_array_defs(snd_config_t *parent, input_t *input, int skip, int override)
@ -4608,12 +4608,12 @@ int snd_config_update_r(snd_config_t **_top, snd_config_update_t **_update, cons
return err;
_reread:
*_top = NULL;
*_update = NULL;
if (update) {
snd_config_update_free(update);
update = NULL;
}
*_top = NULL;
*_update = NULL;
if (update) {
snd_config_update_free(update);
update = NULL;
}
if (top) {
snd_config_delete(top);
top = NULL;
@ -5221,7 +5221,7 @@ static int _snd_config_evaluate(snd_config_t *src,
* replaces those nodes with the respective function results.
*/
int snd_config_evaluate(snd_config_t *config, snd_config_t *root,
snd_config_t *private_data, snd_config_t **result)
snd_config_t *private_data, snd_config_t **result)
{
/* FIXME: Only in place evaluation is currently implemented */
assert(result == NULL);
@ -5725,7 +5725,7 @@ int snd_config_expand(snd_config_t *config, snd_config_t *root, const char *args
*result = res;
err = 1;
_end:
if (subs)
if (subs)
snd_config_delete(subs);
return err;
}

20
src/confmisc.c
View file

@ -558,7 +558,7 @@ static int snd_func_iops(snd_config_t **dst,
\endcode
*/
int snd_func_iadd(snd_config_t **dst, snd_config_t *root,
snd_config_t *src, snd_config_t *private_data)
snd_config_t *src, snd_config_t *private_data)
{
return snd_func_iops(dst, root, src, private_data, 0);
}
@ -972,8 +972,8 @@ int snd_func_card_id(snd_config_t **dst, snd_config_t *root, snd_config_t *src,
err = snd_config_imake_string(dst, id,
snd_ctl_card_info_get_id(&info));
__error:
if (ctl)
snd_ctl_close(ctl);
if (ctl)
snd_ctl_close(ctl);
return err;
}
#ifndef DOC_HIDDEN
@ -1023,8 +1023,8 @@ int snd_func_card_name(snd_config_t **dst, snd_config_t *root,
err = snd_config_imake_safe_string(dst, id,
snd_ctl_card_info_get_name(&info));
__error:
if (ctl)
snd_ctl_close(ctl);
if (ctl)
snd_ctl_close(ctl);
return err;
}
#ifndef DOC_HIDDEN
@ -1117,8 +1117,8 @@ int snd_func_pcm_id(snd_config_t **dst, snd_config_t *root, snd_config_t *src, v
err = snd_config_imake_string(dst, id,
snd_pcm_info_get_id(&info));
__error:
if (ctl)
snd_ctl_close(ctl);
if (ctl)
snd_ctl_close(ctl);
return err;
}
#ifndef DOC_HIDDEN
@ -1217,14 +1217,14 @@ int snd_func_pcm_args_by_class(snd_config_t **dst, snd_config_t *root, snd_confi
index == idx++)
goto __out;
}
snd_ctl_close(ctl);
snd_ctl_close(ctl);
ctl = NULL;
}
err = -ENODEV;
__out:
if (ctl)
snd_ctl_close(ctl);
if (ctl)
snd_ctl_close(ctl);
if (err < 0)
return err;
if((err = snd_config_get_id(src, &id)) >= 0) {

10
src/control/control.c
View file

@ -52,7 +52,7 @@ file. The format is:
\verbatim
index [ID ] Driver - name
longname
longname
\endverbatim
Note that the mixername and components are not listed.
@ -353,7 +353,7 @@ int snd_ctl_poll_descriptors_revents(snd_ctl_t *ctl, struct pollfd *pfds, unsign
return ctl->ops->poll_revents(ctl, pfds, nfds, revents);
if (nfds == 1) {
*revents = pfds->revents;
return 0;
return 0;
}
return -EINVAL;
}
@ -1039,7 +1039,7 @@ int snd_ctl_elem_write(snd_ctl_t *ctl, snd_ctl_elem_value_t *data)
static int snd_ctl_tlv_do(snd_ctl_t *ctl, int op_flag,
const snd_ctl_elem_id_t *id,
unsigned int *tlv, unsigned int tlv_size)
unsigned int *tlv, unsigned int tlv_size)
{
snd_ctl_elem_info_t *info = NULL;
int err;
@ -1060,8 +1060,8 @@ static int snd_ctl_tlv_do(snd_ctl_t *ctl, int op_flag,
}
err = ctl->ops->element_tlv(ctl, op_flag, id->numid, tlv, tlv_size);
__err:
if (info)
free(info);
if (info)
free(info);
return err;
}

2
src/control/control_ext.c
View file

@ -458,7 +458,7 @@ static int snd_ctl_ext_poll_revents(snd_ctl_t *handle, struct pollfd *pfds, unsi
return ext->callback->poll_revents(ext, pfds, nfds, revents);
if (nfds == 1) {
*revents = pfds->revents;
return 0;
return 0;
}
return -EINVAL;
}

2
src/control/control_hw.c
View file

@ -232,7 +232,7 @@ static int snd_ctl_hw_elem_tlv(snd_ctl_t *handle, int op_flag,
switch (op_flag) {
case -1: inum = SNDRV_CTL_IOCTL_TLV_COMMAND; break;
case 0: inum = SNDRV_CTL_IOCTL_TLV_READ; break;
case 0: inum = SNDRV_CTL_IOCTL_TLV_READ; break;
case 1: inum = SNDRV_CTL_IOCTL_TLV_WRITE; break;
default: return -EINVAL;
}

48
src/control/namehint.c
View file

@ -261,7 +261,7 @@ static int try_config(snd_config_t *config,
snd_config_get_string(cfg, &str) >= 0 &&
((strncmp(base, str, strlen(base)) == 0 &&
str[strlen(base)] == '.') || strchr(str, '.') == NULL))
goto __skip_add;
goto __skip_add;
if (list->card >= 0 && list->device >= 0)
sprintf(buf, "%s:CARD=%s,DEV=%i", name, snd_ctl_card_info_get_id(list->info), list->device);
else if (list->card >= 0)
@ -294,7 +294,7 @@ static int try_config(snd_config_t *config,
cfg1 = res;
level = 0;
__hint:
level++;
level++;
if (snd_config_search(cfg1, "type", &cfg) >= 0 &&
snd_config_get_string(cfg, &str) >= 0 &&
strcmp(str, "hw") == 0) {
@ -363,7 +363,7 @@ static int try_config(snd_config_t *config,
goto __skip_add;
if (snd_config_search(cfg1, "slave", &cfg) >= 0 &&
snd_config_search(cfg, base, &cfg1) >= 0)
goto __hint;
goto __hint;
snd_config_delete(res);
res = NULL;
cleanup_res = 0;
@ -395,38 +395,38 @@ static int try_config(snd_config_t *config,
__ok:
err = 0;
__cleanup:
if (err >= 0) {
list->device = dev;
str = list->card >= 0 ? get_dev_name(list) : NULL;
if (str != NULL) {
level = (buf1 == NULL ? 0 : strlen(buf1)) + 1 + strlen(str);
buf2 = realloc((char *)str, level + 1);
if (buf2 != NULL) {
if (buf1 != NULL) {
str = strchr(buf2, '|');
if (str != NULL)
if (err >= 0) {
list->device = dev;
str = list->card >= 0 ? get_dev_name(list) : NULL;
if (str != NULL) {
level = (buf1 == NULL ? 0 : strlen(buf1)) + 1 + strlen(str);
buf2 = realloc((char *)str, level + 1);
if (buf2 != NULL) {
if (buf1 != NULL) {
str = strchr(buf2, '|');
if (str != NULL)
memmove(buf2 + (level - strlen(str)), str, strlen(str));
else
str = buf2 + strlen(buf2);
*(char *)str++ = '\n';
memcpy((char *)str, buf1, strlen(buf1));
buf2[level] = '\0';
*(char *)str++ = '\n';
memcpy((char *)str, buf1, strlen(buf1));
buf2[level] = '\0';
free(buf1);
}
buf1 = buf2;
} else {
free((char *)str);
}
} else if (list->device >= 0)
goto __skip_add;
err = hint_list_add(list, buf, buf1);
} else if (list->device >= 0)
goto __skip_add;
err = hint_list_add(list, buf, buf1);
}
__skip_add:
if (res && cleanup_res)
snd_config_delete(res);
snd_config_delete(res);
if (buf1)
free(buf1);
free(buf);
free(buf);
return err;
}
@ -510,7 +510,7 @@ static int add_card(snd_config_t *config, snd_config_t *rw_config, struct hint_l
}
err = 0;
__error:
snd_ctl_close(list->ctl);
snd_ctl_close(list->ctl);
return err;
}
@ -665,9 +665,9 @@ int snd_device_name_hint(int card, const char *iface, void ***hints)
if (!err && !list.list)
err = hint_list_add(&list, NULL, NULL);
if (err < 0)
snd_device_name_free_hint((void **)list.list);
snd_device_name_free_hint((void **)list.list);
else
*hints = (void **)list.list;
*hints = (void **)list.list;
free(list.cardname);
if (local_config_rw)
snd_config_delete(local_config_rw);

2
src/control/setup.c
View file

@ -571,7 +571,7 @@ static int add_elem(snd_sctl_t *h, snd_config_t *_conf, snd_config_t *private_da
list_add_tail(&elem->list, &h->elems);
_err:
if (err < 0 && elem) {
if (err < 0 && elem) {
if (elem->id)
snd_ctl_elem_id_free(elem->id);
if (elem->info)

4
src/dlmisc.c
View file

@ -332,8 +332,8 @@ snd_dlobj_cache_get0(const char *lib, const char *name,
errbuf[0] = '\0';
dlobj = INTERNAL(snd_dlopen)(lib, RTLD_NOW,
verbose ? errbuf : 0,
verbose ? sizeof(errbuf) : 0);
verbose ? errbuf : 0,
verbose ? sizeof(errbuf) : 0);
if (dlobj == NULL) {
if (verbose)
snd_error(CORE, "Cannot open shared library %s (%s)",

14
src/hwdep/hwdep.c
View file

@ -209,7 +209,7 @@ int snd_hwdep_open_lconf(snd_hwdep_t **hwdep, const char *name,
int snd_hwdep_close(snd_hwdep_t *hwdep)
{
int err;
assert(hwdep);
assert(hwdep);
err = hwdep->ops->close(hwdep);
if (hwdep->dl_handle)
snd_dlclose(hwdep->dl_handle);
@ -296,12 +296,12 @@ int snd_hwdep_poll_descriptors(snd_hwdep_t *hwdep, struct pollfd *pfds, unsigned
*/
int snd_hwdep_poll_descriptors_revents(snd_hwdep_t *hwdep, struct pollfd *pfds, unsigned int nfds, unsigned short *revents)
{
assert(hwdep && pfds && revents);
if (nfds == 1) {
*revents = pfds->revents;
return 0;
}
return -EINVAL;
assert(hwdep && pfds && revents);
if (nfds == 1) {
*revents = pfds->revents;
return 0;
}
return -EINVAL;
}
/**

2
src/mixer/mixer.c
View file

@ -752,7 +752,7 @@ int snd_mixer_poll_descriptors_revents(snd_mixer_t *mixer, struct pollfd *pfds,
{
unsigned int idx;
unsigned short res;
assert(mixer && pfds && revents);
assert(mixer && pfds && revents);
if (nfds == 0)
return -EINVAL;
res = 0;

2
src/mixer/simple_abst.c
View file

@ -350,7 +350,7 @@ int snd_mixer_simple_basic_register(snd_mixer_t *mixer,
__error:
if (top)
snd_config_delete(top);
if (class)
if (class)
snd_mixer_class_free(class);
return err;
}

10
src/mixer/simple_none.c
View file

@ -1215,9 +1215,9 @@ static int ask_vol_dB_ops(snd_mixer_elem_t *elem,
}
static int get_dB_ops(snd_mixer_elem_t *elem,
int dir,
snd_mixer_selem_channel_id_t channel,
long *value)
int dir,
snd_mixer_selem_channel_id_t channel,
long *value)
{
selem_none_t *s = snd_mixer_elem_get_private(elem);
selem_ctl_t *c;
@ -1264,7 +1264,7 @@ static int set_volume_ops(snd_mixer_elem_t *elem, int dir,
}
static int ask_dB_vol_ops(snd_mixer_elem_t *elem, int dir,
long dbValue, long *value, int xdir)
long dbValue, long *value, int xdir)
{
selem_none_t *s = snd_mixer_elem_get_private(elem);
selem_ctl_t *c;
@ -1446,7 +1446,7 @@ static int simple_add1(snd_mixer_class_t *class, const char *name,
if (ctype == SND_CTL_ELEM_TYPE_ENUMERATED)
type = CTL_GLOBAL_ENUM;
else if (ctype != SND_CTL_ELEM_TYPE_BOOLEAN &&
ctype != SND_CTL_ELEM_TYPE_INTEGER)
ctype != SND_CTL_ELEM_TYPE_INTEGER)
return 0;
break;
case CTL_GLOBAL_ROUTE:

30
src/pcm/ladspa.h
View file

@ -316,23 +316,23 @@ typedef int LADSPA_PortRangeHintDescriptor;
#define LADSPA_IS_HINT_HAS_DEFAULT(x) ((x) & LADSPA_HINT_DEFAULT_MASK)
#define LADSPA_IS_HINT_DEFAULT_MINIMUM(x) (((x) & LADSPA_HINT_DEFAULT_MASK) \
== LADSPA_HINT_DEFAULT_MINIMUM)
== LADSPA_HINT_DEFAULT_MINIMUM)
#define LADSPA_IS_HINT_DEFAULT_LOW(x) (((x) & LADSPA_HINT_DEFAULT_MASK) \
== LADSPA_HINT_DEFAULT_LOW)
== LADSPA_HINT_DEFAULT_LOW)
#define LADSPA_IS_HINT_DEFAULT_MIDDLE(x) (((x) & LADSPA_HINT_DEFAULT_MASK) \
== LADSPA_HINT_DEFAULT_MIDDLE)
== LADSPA_HINT_DEFAULT_MIDDLE)
#define LADSPA_IS_HINT_DEFAULT_HIGH(x) (((x) & LADSPA_HINT_DEFAULT_MASK) \
== LADSPA_HINT_DEFAULT_HIGH)
== LADSPA_HINT_DEFAULT_HIGH)
#define LADSPA_IS_HINT_DEFAULT_MAXIMUM(x) (((x) & LADSPA_HINT_DEFAULT_MASK) \
== LADSPA_HINT_DEFAULT_MAXIMUM)
== LADSPA_HINT_DEFAULT_MAXIMUM)
#define LADSPA_IS_HINT_DEFAULT_0(x) (((x) & LADSPA_HINT_DEFAULT_MASK) \
== LADSPA_HINT_DEFAULT_0)
== LADSPA_HINT_DEFAULT_0)
#define LADSPA_IS_HINT_DEFAULT_1(x) (((x) & LADSPA_HINT_DEFAULT_MASK) \
== LADSPA_HINT_DEFAULT_1)
== LADSPA_HINT_DEFAULT_1)
#define LADSPA_IS_HINT_DEFAULT_100(x) (((x) & LADSPA_HINT_DEFAULT_MASK) \
== LADSPA_HINT_DEFAULT_100)
== LADSPA_HINT_DEFAULT_100)
#define LADSPA_IS_HINT_DEFAULT_440(x) (((x) & LADSPA_HINT_DEFAULT_MASK) \
== LADSPA_HINT_DEFAULT_440)
== LADSPA_HINT_DEFAULT_440)
typedef struct _LADSPA_PortRangeHint {
@ -435,7 +435,7 @@ typedef struct _LADSPA_Descriptor {
Note that instance initialisation should generally occur in
activate() rather than here. */
LADSPA_Handle (*instantiate)(const struct _LADSPA_Descriptor * Descriptor,
unsigned long SampleRate);
unsigned long SampleRate);
/* This member is a function pointer that connects a port on an
instantiated plugin to a memory location at which a block of data
@ -464,8 +464,8 @@ typedef struct _LADSPA_Descriptor {
However, overlapped buffers or use of a single buffer for both
audio and control data may result in unexpected behaviour. */
void (*connect_port)(LADSPA_Handle Instance,
unsigned long Port,
LADSPA_Data * DataLocation);
unsigned long Port,
LADSPA_Data * DataLocation);
/* This member is a function pointer that initialises a plugin
instance and activates it for use. This is separated from
@ -503,7 +503,7 @@ typedef struct _LADSPA_Descriptor {
then there are various things that the plugin should not do
within the run() or run_adding() functions (see above). */
void (*run)(LADSPA_Handle Instance,
unsigned long SampleCount);
unsigned long SampleCount);
/* This method is a function pointer that runs an instance of a
plugin for a block. This has identical behaviour to run() except
@ -519,7 +519,7 @@ typedef struct _LADSPA_Descriptor {
this function pointer must be set to NULL. When it is provided,
the function set_run_adding_gain() must be provided also. */
void (*run_adding)(LADSPA_Handle Instance,
unsigned long SampleCount);
unsigned long SampleCount);
/* This method is a function pointer that sets the output gain for
use when run_adding() is called (see above). If this function is
@ -531,7 +531,7 @@ typedef struct _LADSPA_Descriptor {
run_adding() function is provided. When it is absent this
function pointer must be set to NULL. */
void (*set_run_adding_gain)(LADSPA_Handle Instance,
LADSPA_Data Gain);
LADSPA_Data Gain);
/* This is the counterpart to activate() (see above). If there is
nothing for deactivate() to do then the plugin writer may provide

50
src/pcm/mask_inline.h
View file

@ -32,36 +32,36 @@
MASK_INLINE unsigned int ld2(uint32_t v)
{
unsigned r = 0;
unsigned r = 0;
if (v >= 0x10000) {
v >>= 16;
r += 16;
}
if (v >= 0x100) {
v >>= 8;
r += 8;
}
if (v >= 0x10) {
v >>= 4;
r += 4;
}
if (v >= 4) {
v >>= 2;
r += 2;
}
if (v >= 2)
r++;
return r;
if (v >= 0x10000) {
v >>= 16;
r += 16;
}
if (v >= 0x100) {
v >>= 8;
r += 8;
}
if (v >= 0x10) {
v >>= 4;
r += 4;
}
if (v >= 4) {
v >>= 2;
r += 2;
}
if (v >= 2)
r++;
return r;
}
MASK_INLINE unsigned int hweight32(uint32_t v)
{
v = (v & 0x55555555) + ((v >> 1) & 0x55555555);
v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
v = (v & 0x0F0F0F0F) + ((v >> 4) & 0x0F0F0F0F);
v = (v & 0x00FF00FF) + ((v >> 8) & 0x00FF00FF);
return (v & 0x0000FFFF) + ((v >> 16) & 0x0000FFFF);
v = (v & 0x55555555) + ((v >> 1) & 0x55555555);
v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
v = (v & 0x0F0F0F0F) + ((v >> 4) & 0x0F0F0F0F);
v = (v & 0x00FF00FF) + ((v >> 8) & 0x00FF00FF);
return (v & 0x0000FFFF) + ((v >> 16) & 0x0000FFFF);
}
MASK_INLINE size_t snd_mask_sizeof(void)

110
src/pcm/pcm.c
View file

@ -2343,7 +2343,7 @@ int snd_pcm_dump_hw_setup(snd_pcm_t *pcm, snd_output_t *out)
snd_check(PCM, "PCM not set up");
return -EIO;
}
snd_output_printf(out, " stream : %s\n", snd_pcm_stream_name(pcm->stream));
snd_output_printf(out, " stream : %s\n", snd_pcm_stream_name(pcm->stream));
snd_output_printf(out, " access : %s\n", snd_pcm_access_name(pcm->access));
snd_output_printf(out, " format : %s\n", snd_pcm_format_name(pcm->format));
snd_output_printf(out, " subformat : %s\n", snd_pcm_subformat_name(pcm->subformat));
@ -2995,9 +2995,9 @@ int snd_pcm_wait_nocheck(snd_pcm_t *pcm, int timeout)
__snd_pcm_lock(pcm->fast_op_arg);
if (err_poll < 0) {
if (errno == EINTR && !PCMINABORT(pcm) && !(pcm->mode & SND_PCM_EINTR))
continue;
continue;
return -errno;
}
}
if (! err_poll)
break;
err = __snd_pcm_poll_revents(pcm, pfd, npfds, &revents);
@ -3164,13 +3164,13 @@ int snd_pcm_area_silence(const snd_pcm_channel_area_t *dst_area, snd_pcm_uframes
dst = snd_pcm_channel_area_addr(dst_area, dst_offset);
width = snd_pcm_format_physical_width(format);
silence = snd_pcm_format_silence_64(format);
/*
* Iterate copying silent sample for sample data aligned to 64 bit.
* This is a fast path.
*/
if (dst_area->step == (unsigned int) width &&
width != 24 &&
((intptr_t)dst & 7) == 0) {
/*
* Iterate copying silent sample for sample data aligned to 64 bit.
* This is a fast path.
*/
if (dst_area->step == (unsigned int) width &&
width != 24 &&
((intptr_t)dst & 7) == 0) {
unsigned int dwords = samples * width / 64;
uint64_t *dstp = (uint64_t *)dst;
samples -= dwords * 64 / width;
@ -6354,10 +6354,10 @@ int snd_pcm_hw_params_get_min_align(const snd_pcm_hw_params_t *params, snd_pcm_u
return err;
// compute frame bits
fb = snd_pcm_format_physical_width((snd_pcm_format_t)format) * channels;
min_align = 1;
min_align = 1;
while (fb % 8) {
fb *= 2;
min_align *= 2;
min_align *= 2;
}
if (val)
*val = min_align;
@ -7938,8 +7938,8 @@ int snd_pcm_slave_conf(snd_config_t *root, snd_config_t *conf,
pcm_conf = NULL;
err = 0;
_err:
if (pcm_conf)
snd_config_delete(pcm_conf);
if (pcm_conf)
snd_config_delete(pcm_conf);
if (to_free)
snd_config_delete(conf);
return err;
@ -8017,7 +8017,7 @@ static void snd_pcm_unlink_ptr(snd_pcm_t *pcm, snd_pcm_rbptr_t *pcm_rbptr,
return;
__found:
pcm_rbptr->master = NULL;
pcm_rbptr->master = NULL;
pcm_rbptr->ptr = NULL;
pcm_rbptr->fd = -1;
pcm_rbptr->offset = 0UL;
@ -8772,39 +8772,39 @@ _snd_pcm_parse_config_chmaps(snd_config_t *conf)
*/
int snd_pcm_recover(snd_pcm_t *pcm, int err, int silent)
{
if (err > 0)
err = -err;
if (err == -EINTR) /* nothing to do, continue */
return 0;
if (err == -EPIPE) {
const char *s;
if (snd_pcm_stream(pcm) == SND_PCM_STREAM_PLAYBACK)
s = "underrun";
else
s = "overrun";
if (!silent)
if (err > 0)
err = -err;
if (err == -EINTR) /* nothing to do, continue */
return 0;
if (err == -EPIPE) {
const char *s;
if (snd_pcm_stream(pcm) == SND_PCM_STREAM_PLAYBACK)
s = "underrun";
else
s = "overrun";
if (!silent)
snd_error(PCM, "%s occurred", s);
err = snd_pcm_prepare(pcm);
if (err < 0) {
err = snd_pcm_prepare(pcm);
if (err < 0) {
snd_error(PCM, "cannot recovery from %s, prepare failed: %s", s, snd_strerror(err));
return err;
}
return 0;
}
if (err == -ESTRPIPE) {
while ((err = snd_pcm_resume(pcm)) == -EAGAIN)
/* wait until suspend flag is released */
poll(NULL, 0, 1000);
if (err < 0) {
err = snd_pcm_prepare(pcm);
if (err < 0) {
return err;
}
return 0;
}
if (err == -ESTRPIPE) {
while ((err = snd_pcm_resume(pcm)) == -EAGAIN)
/* wait until suspend flag is released */
poll(NULL, 0, 1000);
if (err < 0) {
err = snd_pcm_prepare(pcm);
if (err < 0) {
snd_error(PCM, "cannot recovery from suspend, prepare failed: %s", snd_strerror(err));
return err;
}
}
return 0;
}
return err;
return err;
}
}
return 0;
}
return err;
}
/**
@ -8819,12 +8819,12 @@ int snd_pcm_recover(snd_pcm_t *pcm, int err, int silent)
* \return 0 on success otherwise a negative error code
*/
int snd_pcm_set_params(snd_pcm_t *pcm,
snd_pcm_format_t format,
snd_pcm_access_t access,
unsigned int channels,
unsigned int rate,
int soft_resample,
unsigned int latency)
snd_pcm_format_t format,
snd_pcm_access_t access,
unsigned int channels,
unsigned int rate,
int soft_resample,
unsigned int latency)
{
snd_pcm_hw_params_t params_saved, params = {0};
snd_pcm_sw_params_t swparams = {0};
@ -8841,7 +8841,7 @@ int snd_pcm_set_params(snd_pcm_t *pcm,
s);
return err;
}
}
/* set software resampling */
err = snd_pcm_hw_params_set_rate_resample(pcm, &params, soft_resample);
if (err < 0) {
@ -9028,8 +9028,8 @@ int snd_pcm_set_params(snd_pcm_t *pcm,
* \return 0 on success otherwise a negative error code
*/
int snd_pcm_get_params(snd_pcm_t *pcm,
snd_pcm_uframes_t *buffer_size,
snd_pcm_uframes_t *period_size)
snd_pcm_uframes_t *buffer_size,
snd_pcm_uframes_t *period_size)
{
snd_pcm_hw_params_t params = {0};
int err;
@ -9037,7 +9037,7 @@ int snd_pcm_get_params(snd_pcm_t *pcm,
assert(pcm);
err = snd_pcm_hw_params_current(pcm, &params);
if (err < 0)
return err;
return err;
err = INTERNAL(snd_pcm_hw_params_get_buffer_size)(&params, buffer_size);
if (err < 0)
return err;

20
src/pcm/pcm_adpcm.c
View file

@ -596,15 +596,15 @@ format and rate must match for both of them.
\code
pcm.name {
type adpcm # Ima-ADPCM conversion PCM
slave STR # Slave name
# or
slave { # Slave definition
pcm STR # Slave PCM name
# or
pcm { } # Slave PCM definition
format STR # Slave format
}
type adpcm # Ima-ADPCM conversion PCM
slave STR # Slave name
# or
slave { # Slave definition
pcm STR # Slave PCM name
# or
pcm { } # Slave PCM definition
format STR # Slave format
}
}
\endcode
@ -663,7 +663,7 @@ int _snd_pcm_adpcm_open(snd_pcm_t **pcmp, const char *name,
return err;
if (snd_pcm_format_linear(sformat) != 1 &&
sformat != SND_PCM_FORMAT_IMA_ADPCM) {
snd_config_delete(sconf);
snd_config_delete(sconf);
snd_error(PCM, "invalid slave format");
return -EINVAL;
}

20
src/pcm/pcm_alaw.c
View file

@ -471,15 +471,15 @@ format and rate must match for both of them.
\code
pcm.name {
type alaw # A-Law conversion PCM
slave STR # Slave name
# or
slave { # Slave definition
pcm STR # Slave PCM name
# or
pcm { } # Slave PCM definition
format STR # Slave format
}
type alaw # A-Law conversion PCM
slave STR # Slave name
# or
slave { # Slave definition
pcm STR # Slave PCM name
# or
pcm { } # Slave PCM definition
format STR # Slave format
}
}
\endcode
@ -538,7 +538,7 @@ int _snd_pcm_alaw_open(snd_pcm_t **pcmp, const char *name,
return err;
if (snd_pcm_format_linear(sformat) != 1 &&
sformat != SND_PCM_FORMAT_A_LAW) {
snd_config_delete(sconf);
snd_config_delete(sconf);
snd_error(PCM, "invalid slave format");
return -EINVAL;
}

30
src/pcm/pcm_asym.c
View file

@ -22,21 +22,21 @@ Slave PCMs can be defined asymmetrically for both directions.
\code
pcm.name {
type asym # Asym PCM
playback STR # Playback slave name
# or
playback { # Playback slave definition
pcm STR # Slave PCM name
# or
pcm { } # Slave PCM definition
}
capture STR # Capture slave name
# or
capture { # Capture slave definition
pcm STR # Slave PCM name
# or
pcm { } # Slave PCM definition
}
type asym # Asym PCM
playback STR # Playback slave name
# or
playback { # Playback slave definition
pcm STR # Slave PCM name
# or
pcm { } # Slave PCM definition
}
capture STR # Capture slave name
# or
capture { # Capture slave definition
pcm STR # Slave PCM name
# or
pcm { } # Slave PCM definition
}
}
\endcode

12
src/pcm/pcm_direct.c
View file

@ -120,7 +120,7 @@ retryget:
if ((tmpid = shmget(dmix->ipc_key, 0, dmix->ipc_perm)) != -1)
if (!shmctl(tmpid, IPC_STAT, &buf))
if (!buf.shm_nattch)
/* no users so destroy the segment */
/* no users so destroy the segment */
if (!shmctl(tmpid, IPC_RMID, NULL))
goto retryget;
return err;
@ -309,7 +309,7 @@ static int _snd_send_fd(int sock, void *data, size_t len, int fd)
msghdr.msg_name = NULL;
msghdr.msg_namelen = 0;
msghdr.msg_iov = &vec;
msghdr.msg_iovlen = 1;
msghdr.msg_iovlen = 1;
msghdr.msg_control = cmsg;
msghdr.msg_controllen = cmsg_len;
msghdr.msg_flags = 0;
@ -1057,7 +1057,7 @@ int snd_pcm_direct_sw_params(snd_pcm_t *pcm, snd_pcm_sw_params_t *params)
int snd_pcm_direct_channel_info(snd_pcm_t *pcm, snd_pcm_channel_info_t * info)
{
return snd_pcm_channel_info_shm(pcm, info, -1);
return snd_pcm_channel_info_shm(pcm, info, -1);
}
int snd_pcm_direct_mmap(snd_pcm_t *pcm ATTRIBUTE_UNUSED)
@ -1202,10 +1202,10 @@ int snd_pcm_direct_initialize_slave(snd_pcm_direct_t *dmix, snd_pcm_t *spcm, str
int loops = 10;
__again:
if (loops-- <= 0) {
if (loops-- <= 0) {
snd_error(PCM, "unable to find a valid configuration for slave");
return -EINVAL;
}
return -EINVAL;
}
ret = snd_pcm_hw_params_any(spcm, &hw_params);
if (ret < 0) {
snd_error(PCM, "snd_pcm_hw_params_any failed");

12
src/pcm/pcm_dmix.c
View file

@ -82,7 +82,7 @@ retryshm:
if (errno == EINVAL)
if ((tmpid = shmget(dmix->ipc_key + 1, 0, dmix->ipc_perm)) != -1)
if (!shmctl(tmpid, IPC_STAT, &buf))
if (!buf.shm_nattch)
if (!buf.shm_nattch)
/* no users so destroy the segment */
if (!shmctl(tmpid, IPC_RMID, NULL))
goto retryshm;
@ -784,11 +784,11 @@ static int snd_pcm_dmix_close(snd_pcm_t *pcm)
snd_timer_close(dmix->timer);
snd_pcm_direct_semaphore_down(dmix, DIRECT_IPC_SEM_CLIENT);
snd_pcm_close(dmix->spcm);
if (dmix->server)
snd_pcm_direct_server_discard(dmix);
if (dmix->client)
snd_pcm_direct_client_discard(dmix);
shm_sum_discard(dmix);
if (dmix->server)
snd_pcm_direct_server_discard(dmix);
if (dmix->client)
snd_pcm_direct_client_discard(dmix);
shm_sum_discard(dmix);
if (snd_pcm_direct_shm_discard(dmix)) {
if (snd_pcm_direct_semaphore_discard(dmix))
snd_pcm_direct_semaphore_final(dmix, DIRECT_IPC_SEM_CLIENT);

24
src/pcm/pcm_dmix_generic.c
View file

@ -289,12 +289,12 @@ static void generic_mix_areas_16_swap(unsigned int size,
}
static void generic_remix_areas_16_swap(unsigned int size,
volatile signed short *dst,
signed short *src,
volatile signed int *sum,
size_t dst_step,
size_t src_step,
size_t sum_step)
volatile signed short *dst,
signed short *src,
volatile signed int *sum,
size_t dst_step,
size_t src_step,
size_t sum_step)
{
register signed int sample;
@ -354,12 +354,12 @@ static void generic_mix_areas_32_swap(unsigned int size,
}
static void generic_remix_areas_32_swap(unsigned int size,
volatile signed int *dst,
signed int *src,
volatile signed int *sum,
size_t dst_step,
size_t src_step,
size_t sum_step)
volatile signed int *dst,
signed int *src,
volatile signed int *sum,
size_t dst_step,
size_t src_step,
size_t sum_step)
{
register signed int sample;

2
src/pcm/pcm_dmix_i386.h
View file

@ -244,7 +244,7 @@ static void MIX_AREAS_16_MMX(unsigned int size,
"\tdecl %[size]\n"
"\tjnz 1b\n"
"\temms\n"
"5:"
"5:"
#ifdef BOUNDED_EBX
"\tmovl %[old_ebx], %%ebx\n" /* ebx is GOT pointer (-fPIC) */
#endif

6
src/pcm/pcm_dmix_x86_64.h
View file

@ -137,7 +137,7 @@ static void MIX_AREAS_16(unsigned int size,
#ifdef BOUNDED_RBX
, [old_rbx] "=m" (old_rbx)
#endif
: [dst] "m" (dst), [src] "m" (src), [sum] "m" (sum),
: [dst] "m" (dst), [src] "m" (src), [sum] "m" (sum),
[dst_step] "im" (dst_step), [src_step] "im" (src_step),
[sum_step] "im" (sum_step)
: "rsi", "rdi", "edx", "ecx", "eax", "memory", "cc"
@ -279,7 +279,7 @@ static void MIX_AREAS_32(unsigned int size,
#ifdef BOUNDED_RBX
, [old_rbx] "=m" (old_rbx)
#endif
: [dst] "m" (dst), [src] "m" (src), [sum] "m" (sum),
: [dst] "m" (dst), [src] "m" (src), [sum] "m" (sum),
[dst_step] "im" (dst_step), [src_step] "im" (src_step),
[sum_step] "im" (sum_step)
: "rsi", "rdi", "edx", "ecx", "eax", "memory", "cc"
@ -403,7 +403,7 @@ static void MIX_AREAS_24(unsigned int size,
#ifdef BOUNDED_RBX
, [old_rbx] "=m" (old_rbx)
#endif
: [dst] "m" (dst), [src] "m" (src), [sum] "m" (sum),
: [dst] "m" (dst), [src] "m" (src), [sum] "m" (sum),
[dst_step] "im" (dst_step), [src_step] "im" (src_step),
[sum_step] "im" (sum_step)
: "rsi", "rdi", "edx", "ecx", "eax", "memory", "cc"

8
src/pcm/pcm_dshare.c
View file

@ -484,10 +484,10 @@ static int snd_pcm_dshare_close(snd_pcm_t *pcm)
snd_pcm_direct_semaphore_down(dshare, DIRECT_IPC_SEM_CLIENT);
dshare->shmptr->u.dshare.chn_mask &= ~dshare->u.dshare.chn_mask;
snd_pcm_close(dshare->spcm);
if (dshare->server)
snd_pcm_direct_server_discard(dshare);
if (dshare->client)
snd_pcm_direct_client_discard(dshare);
if (dshare->server)
snd_pcm_direct_server_discard(dshare);
if (dshare->client)
snd_pcm_direct_client_discard(dshare);
if (snd_pcm_direct_shm_discard(dshare)) {
if (snd_pcm_direct_semaphore_discard(dshare))
snd_pcm_direct_semaphore_final(dshare, DIRECT_IPC_SEM_CLIENT);

12
src/pcm/pcm_dsnoop.c
View file

@ -119,7 +119,7 @@ static void snd_pcm_dsnoop_sync_area(snd_pcm_t *pcm, snd_pcm_uframes_t slave_hw_
size -= transfer;
snoop_areas(dsnoop, src_areas, dst_areas, slave_hw_ptr, hw_ptr, transfer);
slave_hw_ptr += transfer;
slave_hw_ptr %= dsnoop->slave_buffer_size;
slave_hw_ptr %= dsnoop->slave_buffer_size;
hw_ptr += transfer;
hw_ptr %= pcm->buffer_size;
}
@ -373,10 +373,10 @@ static int snd_pcm_dsnoop_close(snd_pcm_t *pcm)
snd_timer_close(dsnoop->timer);
snd_pcm_direct_semaphore_down(dsnoop, DIRECT_IPC_SEM_CLIENT);
snd_pcm_close(dsnoop->spcm);
if (dsnoop->server)
snd_pcm_direct_server_discard(dsnoop);
if (dsnoop->client)
snd_pcm_direct_client_discard(dsnoop);
if (dsnoop->server)
snd_pcm_direct_server_discard(dsnoop);
if (dsnoop->client)
snd_pcm_direct_client_discard(dsnoop);
if (snd_pcm_direct_shm_discard(dsnoop)) {
if (snd_pcm_direct_semaphore_discard(dsnoop))
snd_pcm_direct_semaphore_final(dsnoop, DIRECT_IPC_SEM_CLIENT);
@ -660,7 +660,7 @@ int snd_pcm_dsnoop_open(snd_pcm_t **pcmp, const char *name,
return 0;
_err:
if (dsnoop->timer)
if (dsnoop->timer)
snd_timer_close(dsnoop->timer);
if (dsnoop->server)
snd_pcm_direct_server_discard(dsnoop);

4
src/pcm/pcm_empty.c
View file

@ -77,8 +77,8 @@ pcm.name {
* changed in future.
*/
int _snd_pcm_empty_open(snd_pcm_t **pcmp, const char *name ATTRIBUTE_UNUSED,
snd_config_t *root, snd_config_t *conf,
snd_pcm_stream_t stream, int mode)
snd_config_t *root, snd_config_t *conf,
snd_pcm_stream_t stream, int mode)
{
snd_config_t *slave = NULL, *sconf;
snd_config_iterator_t i, next;

18
src/pcm/pcm_file.c
View file

@ -690,7 +690,7 @@ static snd_pcm_sframes_t snd_pcm_file_readn(snd_pcm_t *pcm, void **bufs, snd_pcm
}
static snd_pcm_sframes_t snd_pcm_file_mmap_commit(snd_pcm_t *pcm,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t offset,
snd_pcm_uframes_t size)
{
snd_pcm_file_t *file = pcm->private_data;
@ -982,14 +982,14 @@ to a command, and optionally uses an existing file as an input data source
\code
pcm.name {
type file # File PCM
slave STR # Slave name
# or
slave { # Slave definition
pcm STR # Slave PCM name
# or
pcm { } # Slave PCM definition
}
type file # File PCM
slave STR # Slave name
# or
slave { # Slave definition
pcm STR # Slave PCM name
# or
pcm { } # Slave PCM definition
}
file STR # Output filename (or shell command the stream
# will be piped to if STR starts with the pipe
# char).

4
src/pcm/pcm_hooks.c
View file

@ -283,9 +283,9 @@ pcm.NAME {
slave STR # Slave name
# or
slave { # Slave definition
pcm STR # Slave PCM name
pcm STR # Slave PCM name
# or
pcm { } # Slave PCM definition
pcm { } # Slave PCM definition
}
hooks {
ID STR # Hook name (see pcm_hook)

10
src/pcm/pcm_hw.c
View file

@ -456,7 +456,7 @@ static int snd_pcm_hw_change_timer(snd_pcm_t *pcm, int enable)
return -EINVAL;
}
hw->period_timer_pfd.events = POLLIN;
hw->period_timer_pfd.revents = 0;
hw->period_timer_pfd.revents = 0;
snd_timer_poll_descriptors(hw->period_timer,
&hw->period_timer_pfd, 1);
hw->period_timer_need_poll = 0;
@ -473,7 +473,7 @@ static int snd_pcm_hw_change_timer(snd_pcm_t *pcm, int enable)
* In older versions, check via poll before read() is
* needed because of the confliction between
* TIMER_START and FIONBIO ioctls.
*/
*/
if (ver < SNDRV_PROTOCOL_VERSION(2, 0, 4))
hw->period_timer_need_poll = 1;
/*
@ -1785,7 +1785,7 @@ int snd_pcm_hw_open(snd_pcm_t **pcmp, const char *name,
sprintf(filename, filefmt, card, device);
__again:
if (attempt++ > 3) {
if (attempt++ > 3) {
ret = -EBUSY;
goto _err;
}
@ -2085,8 +2085,8 @@ int _snd_pcm_hw_open(snd_pcm_t **pcmp, const char *name,
return 0;
fail:
snd_pcm_free_chmaps(chmap);
return err;
snd_pcm_free_chmaps(chmap);
return err;
}
#ifndef DOC_HIDDEN

20
src/pcm/pcm_iec958.c
View file

@ -565,7 +565,7 @@ int snd_pcm_iec958_open(snd_pcm_t **pcmp, const char *name, snd_pcm_format_t sfo
snd_pcm_t *slave, int close_slave,
const unsigned char *status_bits,
const unsigned char *preamble_vals,
int hdmi_mode)
int hdmi_mode)
{
snd_pcm_t *pcm;
snd_pcm_iec958_t *iec;
@ -638,14 +638,14 @@ This plugin converts 32bit IEC958 subframe samples to linear, or linear to
\code
pcm.name {
type iec958 # IEC958 subframe conversion PCM
slave STR # Slave name
# or
slave { # Slave definition
pcm STR # Slave PCM name
# or
pcm { } # Slave PCM definition
}
type iec958 # IEC958 subframe conversion PCM
slave STR # Slave name
# or
slave { # Slave definition
pcm STR # Slave PCM name
# or
pcm { } # Slave PCM definition
}
[status status-bytes] # IEC958 status bits (given in byte array)
# IEC958 preamble bits definitions
# B/M/W or Z/X/Y, B = block start, M = even subframe, W = odd subframe
@ -797,7 +797,7 @@ int _snd_pcm_iec958_open(snd_pcm_t **pcmp, const char *name,
if (snd_pcm_format_linear(sformat) != 1 &&
sformat != SND_PCM_FORMAT_IEC958_SUBFRAME_LE &&
sformat != SND_PCM_FORMAT_IEC958_SUBFRAME_BE) {
snd_config_delete(sconf);
snd_config_delete(sconf);
snd_error(PCM, "invalid slave format");
return -EINVAL;
}

856
src/pcm/pcm_ladspa.c
View file

File diff suppressed because it is too large Load diff

18
src/pcm/pcm_lfloat.c
View file

@ -429,15 +429,15 @@ match for both of them.
\code
pcm.name {
type lfloat # Linear<->Float conversion PCM
slave STR # Slave name
# or
slave { # Slave definition
pcm STR # Slave PCM name
# or
pcm { } # Slave PCM definition
format STR # Slave format
}
type lfloat # Linear<->Float conversion PCM
slave STR # Slave name
# or
slave { # Slave definition
pcm STR # Slave PCM name
# or
pcm { } # Slave PCM definition
format STR # Slave format
}
}
\endcode

18
src/pcm/pcm_linear.c
View file

@ -472,15 +472,15 @@ slave PCM. The channel count, format and rate must match for both of them.
\code
pcm.name {
type linear # Linear conversion PCM
slave STR # Slave name
# or
slave { # Slave definition
pcm STR # Slave PCM name
# or
pcm { } # Slave PCM definition
format STR # Slave format
}
type linear # Linear conversion PCM
slave STR # Slave name
# or
slave { # Slave definition
pcm STR # Slave PCM name
# or
pcm { } # Slave PCM definition
format STR # Slave format
}
}
\endcode

4
src/pcm/pcm_local.h
View file

@ -606,13 +606,13 @@ static inline const snd_pcm_channel_area_t *snd_pcm_mmap_areas(snd_pcm_t *pcm)
static inline snd_pcm_uframes_t snd_pcm_mmap_offset(snd_pcm_t *pcm)
{
assert(pcm);
assert(pcm);
return *pcm->appl.ptr % pcm->buffer_size;
}
static inline snd_pcm_uframes_t snd_pcm_mmap_hw_offset(snd_pcm_t *pcm)
{
assert(pcm);
assert(pcm);
return *pcm->hw.ptr % pcm->buffer_size;
}

18
src/pcm/pcm_meter.c
View file

@ -259,7 +259,7 @@ static void *snd_pcm_meter_thread(void *data)
if (scope->enabled)
scope->ops->update(scope);
}
nanosleep(&meter->delay, NULL);
nanosleep(&meter->delay, NULL);
}
list_for_each(pos, &meter->scopes) {
scope = list_entry(pos, snd_pcm_scope_t, list);
@ -716,14 +716,14 @@ pcm_scope.name {
}
pcm.name {
type meter # Meter PCM
slave STR # Slave name
# or
slave { # Slave definition
pcm STR # Slave PCM name
# or
pcm { } # Slave PCM definition
}
type meter # Meter PCM
slave STR # Slave name
# or
slave { # Slave definition
pcm STR # Slave PCM name
# or
pcm { } # Slave PCM definition
}
[frequency INT] # Updates per second
scopes {
ID STR # Scope name (see pcm_scope)

16
src/pcm/pcm_mmap.c
View file

@ -306,12 +306,12 @@ int snd_pcm_mmap(snd_pcm_t *pcm)
size_t size;
unsigned int c1;
if (i->addr) {
a->addr = i->addr;
a->first = i->first;
a->step = i->step;
continue;
}
size = i->first + i->step * (pcm->buffer_size - 1) + pcm->sample_bits;
a->addr = i->addr;
a->first = i->first;
a->step = i->step;
continue;
}
size = i->first + i->step * (pcm->buffer_size - 1) + pcm->sample_bits;
for (c1 = c + 1; c1 < pcm->channels; ++c1) {
snd_pcm_channel_info_t *i1 = &pcm->mmap_channels[c1];
size_t s;
@ -415,7 +415,7 @@ int snd_pcm_mmap(snd_pcm_t *pcm)
switch (i1->type) {
case SND_PCM_AREA_MMAP:
if (i1->u.mmap.fd != i->u.mmap.fd ||
i1->u.mmap.offset != i->u.mmap.offset)
i1->u.mmap.offset != i->u.mmap.offset)
continue;
break;
case SND_PCM_AREA_SHM:
@ -425,7 +425,7 @@ int snd_pcm_mmap(snd_pcm_t *pcm)
case SND_PCM_AREA_LOCAL:
if (pcm->access != SND_PCM_ACCESS_MMAP_INTERLEAVED &&
pcm->access != SND_PCM_ACCESS_RW_INTERLEAVED)
continue;
continue;
break;
default:
assert(0);

18
src/pcm/pcm_mulaw.c
View file

@ -484,15 +484,15 @@ format and rate must match for both of them.
\code
pcm.name {
type mulaw # Mu-Law conversion PCM
slave STR # Slave name
# or
slave { # Slave definition
pcm STR # Slave PCM name
# or
pcm { } # Slave PCM definition
format STR # Slave format
}
type mulaw # Mu-Law conversion PCM
slave STR # Slave name
# or
slave { # Slave definition
pcm STR # Slave PCM name
# or
pcm { } # Slave PCM definition
format STR # Slave format
}
}
\endcode

6
src/pcm/pcm_multi.c
View file

@ -1160,8 +1160,8 @@ This plugin converts multiple streams to one.
\code
pcm.name {
type multi # Multiple streams conversion PCM
slaves { # Slaves definition
type multi # Multiple streams conversion PCM
slaves { # Slaves definition
ID STR # Slave PCM name
# or
ID {
@ -1170,7 +1170,7 @@ pcm.name {
pcm { } # Slave PCM definition
channels INT # Slave channels
}
}
}
bindings { # Bindings table
N {
slave STR # Slave key

12
src/pcm/pcm_null.c
View file

@ -82,11 +82,11 @@ static int snd_pcm_null_info(snd_pcm_t *pcm, snd_pcm_info_t * info)
static snd_pcm_sframes_t snd_pcm_null_avail_update(snd_pcm_t *pcm)
{
snd_pcm_null_t *null = pcm->private_data;
if (null->state == SND_PCM_STATE_PREPARED) {
/* it is required to return the correct avail count for */
/* the prepared stream, otherwise the start is not called */
return snd_pcm_mmap_avail(pcm);
}
if (null->state == SND_PCM_STATE_PREPARED) {
/* it is required to return the correct avail count for */
/* the prepared stream, otherwise the start is not called */
return snd_pcm_mmap_avail(pcm);
}
return pcm->buffer_size;
}
@ -434,7 +434,7 @@ and /dev/full (capture, must be readable).
\code
pcm.name {
type null # Null PCM
type null # Null PCM
[chmap MAP] # Provide channel maps; MAP is a string array
}
\endcode

2
src/pcm/pcm_params.c
View file

@ -1110,7 +1110,7 @@ static int snd_pcm_hw_params_choose(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
if (err >= 0)
err = snd_pcm_hw_param_get_max(params, SND_PCM_HW_PARAM_PERIOD_TIME, &max, &dir);
if (err >= 0 && (long)min < pcm->minperiodtime &&
(long)max > pcm->minperiodtime) {
(long)max > pcm->minperiodtime) {
min = pcm->minperiodtime; dir = 1;
snd_pcm_hw_param_set_min(pcm, params, SND_CHANGE, SND_PCM_HW_PARAM_PERIOD_TIME, &min, &dir);
}

16
src/pcm/pcm_plug.c
View file

@ -1210,17 +1210,17 @@ This plugin converts channels, rate and format on request.
\code
pcm.name {
type plug # Automatic conversion PCM
slave STR # Slave name
# or
slave { # Slave definition
pcm STR # Slave PCM name
# or
pcm { } # Slave PCM definition
type plug # Automatic conversion PCM
slave STR # Slave name
# or
slave { # Slave definition
pcm STR # Slave PCM name
# or
pcm { } # Slave PCM definition
[format STR] # Slave format (default nearest) or "unchanged"
[channels INT] # Slave channels (default nearest) or "unchanged"
[rate INT] # Slave rate (default nearest) or "unchanged"
}
}
route_policy STR # route policy for automatic ttable generation
# STR can be 'default', 'average', 'copy', 'duplicate'
# average: result is average of input channels

8
src/pcm/pcm_plugin.c
View file

@ -198,7 +198,7 @@ snd_pcm_sframes_t snd_pcm_plugin_rewind(snd_pcm_t *pcm, snd_pcm_uframes_t frames
if (frames == 0)
return 0;
sframes = frames;
sframes = frames;
sframes = snd_pcm_rewind(plugin->gen.slave, sframes);
if (sframes < 0)
return sframes;
@ -222,7 +222,7 @@ snd_pcm_sframes_t snd_pcm_plugin_forward(snd_pcm_t *pcm, snd_pcm_uframes_t frame
if (frames == 0)
return 0;
sframes = frames;
sframes = frames;
sframes = INTERNAL(snd_pcm_forward)(plugin->gen.slave, sframes);
if (sframes < 0)
return sframes;
@ -532,8 +532,8 @@ static snd_pcm_sframes_t snd_pcm_plugin_sync_hw_ptr(snd_pcm_t *pcm,
pcm->access != SND_PCM_ACCESS_RW_INTERLEAVED &&
pcm->access != SND_PCM_ACCESS_RW_NONINTERLEAVED)
return snd_pcm_plugin_sync_hw_ptr_capture(pcm, slave_size);
*pcm->hw.ptr = slave_hw_ptr;
return slave_size;
*pcm->hw.ptr = slave_hw_ptr;
return slave_size;
}
static snd_pcm_sframes_t snd_pcm_plugin_avail_update(snd_pcm_t *pcm)

38
src/pcm/pcm_rate.c
View file

@ -237,10 +237,10 @@ static int snd_pcm_rate_hw_refine_cchange(snd_pcm_t *pcm, snd_pcm_hw_params_t *p
period_size->openmin && period_size->openmax &&
period_size->min + 1 == period_size->max) {
if (period_size->min > 0 && (buffer_size->min / period_size->min) * period_size->min == buffer_size->min) {
snd_interval_set_value(period_size, period_size->min);
} else if ((buffer_size->max / period_size->max) * period_size->max == buffer_size->max) {
snd_interval_set_value(period_size, period_size->max);
}
snd_interval_set_value(period_size, period_size->min);
} else if ((buffer_size->max / period_size->max) * period_size->max == buffer_size->max) {
snd_interval_set_value(period_size, period_size->max);
}
}
}
#ifdef DEBUG_REFINE
@ -756,15 +756,15 @@ static snd_pcm_sframes_t snd_pcm_rate_forwardable(snd_pcm_t *pcm ATTRIBUTE_UNUSE
}
static snd_pcm_sframes_t snd_pcm_rate_rewind(snd_pcm_t *pcm ATTRIBUTE_UNUSED,
snd_pcm_uframes_t frames ATTRIBUTE_UNUSED)
snd_pcm_uframes_t frames ATTRIBUTE_UNUSED)
{
return 0;
return 0;
}
static snd_pcm_sframes_t snd_pcm_rate_forward(snd_pcm_t *pcm ATTRIBUTE_UNUSED,
snd_pcm_uframes_t frames ATTRIBUTE_UNUSED)
snd_pcm_uframes_t frames ATTRIBUTE_UNUSED)
{
return 0;
return 0;
}
static int snd_pcm_rate_commit_area(snd_pcm_t *pcm, snd_pcm_rate_t *rate,
@ -958,7 +958,7 @@ static int snd_pcm_rate_grab_next_period(snd_pcm_t *pcm, snd_pcm_uframes_t hw_of
}
#endif
snd_pcm_areas_copy(rate->sareas, xfer,
slave_areas, slave_offset,
slave_areas, slave_offset,
pcm->channels, cont,
rate->gen.slave->format);
result = snd_pcm_mmap_commit(rate->gen.slave, slave_offset, cont);
@ -1627,15 +1627,15 @@ This plugin converts a stream rate. The input and output formats must be linear.
\code
pcm.name {
type rate # Rate PCM
slave STR # Slave name
# or
slave { # Slave definition
pcm STR # Slave PCM name
# or
pcm { } # Slave PCM definition
rate INT # Slave rate
[format STR] # Slave format
}
slave STR # Slave name
# or
slave { # Slave definition
pcm STR # Slave PCM name
# or
pcm { } # Slave PCM definition
rate INT # Slave rate
[format STR] # Slave format
}
converter STR # optional
# or
converter [ STR1 STR2 ... ] # optional
@ -1713,7 +1713,7 @@ int _snd_pcm_rate_open(snd_pcm_t **pcmp, const char *name,
return err;
if (sformat != SND_PCM_FORMAT_UNKNOWN &&
snd_pcm_format_linear(sformat) != 1) {
snd_config_delete(sconf);
snd_config_delete(sconf);
snd_error(PCM, "slave format is not linear");
return -EINVAL;
}

34
src/pcm/pcm_route.c
View file

@ -1245,22 +1245,22 @@ If so, a matching channel map will be selected for the slave.
\code
pcm.name {
type route # Route & Volume conversion PCM
slave STR # Slave name
# or
slave { # Slave definition
pcm STR # Slave PCM name
# or
pcm { } # Slave PCM definition
[format STR] # Slave format
[channels INT] # Slave channels
}
ttable { # Transfer table (bi-dimensional compound of cchannels * schannels numbers)
CCHANNEL {
SCHANNEL REAL # route value (0.0 - 1.0)
}
}
[chmap MAP] # Override channel maps; MAP is a string array
type route # Route & Volume conversion PCM
slave STR # Slave name
# or
slave { # Slave definition
pcm STR # Slave PCM name
# or
pcm { } # Slave PCM definition
[format STR] # Slave format
[channels INT] # Slave channels
}
ttable { # Transfer table (bi-dimensional compound of cchannels * schannels numbers)
CCHANNEL {
SCHANNEL REAL # route value (0.0 - 1.0)
}
}
[chmap MAP] # Override channel maps; MAP is a string array
}
\endcode
@ -1352,7 +1352,7 @@ int _snd_pcm_route_open(snd_pcm_t **pcmp, const char *name,
}
if (sformat != SND_PCM_FORMAT_UNKNOWN &&
snd_pcm_format_linear(sformat) != 1) {
snd_config_delete(sconf);
snd_config_delete(sconf);
snd_error(PCM, "slave format is not linear");
snd_pcm_free_chmaps(chmaps);
return -EINVAL;

24
src/pcm/pcm_share.c
View file

@ -122,7 +122,7 @@ static snd_pcm_uframes_t snd_pcm_share_slave_avail(snd_pcm_share_slave_t *slave)
{
snd_pcm_sframes_t avail;
snd_pcm_t *pcm = slave->pcm;
avail = slave->hw_ptr - *pcm->appl.ptr;
avail = slave->hw_ptr - *pcm->appl.ptr;
if (pcm->stream == SND_PCM_STREAM_PLAYBACK)
avail += pcm->buffer_size;
if (avail < 0)
@ -1569,17 +1569,17 @@ doesn't need the explicit server but access to the shared buffer.
\code
pcm.name {
type share # Share PCM
slave STR # Slave name
# or
slave { # Slave definition
pcm STR # Slave PCM name
[format STR] # Slave format
[channels INT] # Slave channels
[rate INT] # Slave rate
[period_time INT] # Slave period time in us
[buffer_time INT] # Slave buffer time in us
}
type share # Share PCM
slave STR # Slave name
# or
slave { # Slave definition
pcm STR # Slave PCM name
[format STR] # Slave format
[channels INT] # Slave channels
[rate INT] # Slave rate
[period_time INT] # Slave period time in us
[buffer_time INT] # Slave buffer time in us
}
bindings {
N INT # Slave channel INT for client channel N
}

2
src/pcm/pcm_shm.c
View file

@ -781,7 +781,7 @@ performance.
\code
pcm.name {
type shm # Shared memory PCM
type shm # Shared memory PCM
server STR # Server name
pcm STR # PCM name
}

2
src/pcm/pcm_simple.c
View file

@ -109,7 +109,7 @@ static int set_hw_params(snd_pcm_t *pcm,
static int set_sw_params(snd_pcm_t *pcm,
snd_pcm_sw_params_t *sw_params,
snd_spcm_xrun_type_t xrun_type)
snd_spcm_xrun_type_t xrun_type)
{
int err;

24
src/pcm/pcm_softvol.c
View file

@ -475,7 +475,7 @@ static int snd_pcm_softvol_hw_refine_cprepare(snd_pcm_t *pcm,
(1ULL << SND_PCM_FORMAT_S16_BE) |
(1ULL << SND_PCM_FORMAT_S24_LE) |
(1ULL << SND_PCM_FORMAT_S32_LE) |
(1ULL << SND_PCM_FORMAT_S32_BE),
(1ULL << SND_PCM_FORMAT_S32_BE),
(1ULL << (SND_PCM_FORMAT_S24_3LE - 32))
}
};
@ -1101,17 +1101,17 @@ any changes.
\code
pcm.name {
type softvol # Soft Volume conversion PCM
slave STR # Slave name
# or
slave { # Slave definition
pcm STR # Slave PCM name
# or
pcm { } # Slave PCM definition
[format STR] # Slave format
}
control {
name STR # control element id string
type softvol # Soft Volume conversion PCM
slave STR # Slave name
# or
slave { # Slave definition
pcm STR # Slave PCM name
# or
pcm { } # Slave PCM definition
[format STR] # Slave format
}
control {
name STR # control element id string
[card STR] # control card index
[iface STR] # interface of the element
[index INT] # index of the element

24
src/pcm/plugin_ops.h
View file

@ -681,35 +681,35 @@ static void *const get32float_labels[2 * 2] = {
#ifdef GET32F_END
get32f_1234F_1234: tmp_float.f = as_floatc(src);
if (tmp_float.f >= 1.0)
sample = 0x7fffffff;
sample = 0x7fffffff;
else if (tmp_float.f <= -1.0)
sample = 0x80000000;
sample = 0x80000000;
else
sample = (int32_t)(tmp_float.f * (float_t)0x80000000UL);
sample = (int32_t)(tmp_float.f * (float_t)0x80000000UL);
goto GET32F_END;
get32f_4321F_1234: tmp_float.i = bswap_32(as_u32c(src));
if (tmp_float.f >= 1.0)
sample = 0x7fffffff;
sample = 0x7fffffff;
else if (tmp_float.f <= -1.0)
sample = 0x80000000;
sample = 0x80000000;
else
sample = (int32_t)(tmp_float.f * (float_t)0x80000000UL);
sample = (int32_t)(tmp_float.f * (float_t)0x80000000UL);
goto GET32F_END;
get32f_1234D_1234: tmp_double.d = as_doublec(src);
if (tmp_double.d >= 1.0)
sample = 0x7fffffff;
sample = 0x7fffffff;
else if (tmp_double.d <= -1.0)
sample = 0x80000000;
sample = 0x80000000;
else
sample = (int32_t)(tmp_double.d * (double_t)0x80000000UL);
sample = (int32_t)(tmp_double.d * (double_t)0x80000000UL);
goto GET32F_END;
get32f_4321D_1234: tmp_double.l = bswap_64(as_u64c(src));
if (tmp_double.d >= 1.0)
sample = 0x7fffffff;
sample = 0x7fffffff;
else if (tmp_double.d <= -1.0)
sample = 0x80000000;
sample = 0x80000000;
else
sample = (int32_t)(tmp_double.d * (double_t)0x80000000UL);
sample = (int32_t)(tmp_double.d * (double_t)0x80000000UL);
goto GET32F_END;
#endif

2
src/pcm/scopes/level.c
View file

@ -58,7 +58,7 @@ static int level_enable(snd_pcm_scope_t *scope)
snd_pcm_scope_set_callback_private(scope, level);
level->win = initscr();
winsdelln(level->win, snd_pcm_meter_get_channels(level->pcm));
getyx(level->win, y, x);
getyx(level->win, y, x);
level->top = y;
return 0;
}

14
src/rawmidi/rawmidi.c
View file

@ -360,7 +360,7 @@ int snd_rawmidi_open_lconf(snd_rawmidi_t **inputp, snd_rawmidi_t **outputp,
int snd_rawmidi_close(snd_rawmidi_t *rawmidi)
{
int err;
assert(rawmidi);
assert(rawmidi);
err = rawmidi->ops->close(rawmidi);
free(rawmidi->name);
if (rawmidi->open_func)
@ -448,12 +448,12 @@ int snd_rawmidi_poll_descriptors(snd_rawmidi_t *rawmidi, struct pollfd *pfds, un
*/
int snd_rawmidi_poll_descriptors_revents(snd_rawmidi_t *rawmidi, struct pollfd *pfds, unsigned int nfds, unsigned short *revents)
{
assert(rawmidi && pfds && revents);
if (nfds == 1) {
*revents = pfds->revents;
return 0;
}
return -EINVAL;
assert(rawmidi && pfds && revents);
if (nfds == 1) {
*revents = pfds->revents;
return 0;
}
return -EINVAL;
}
/**

10
src/rawmidi/rawmidi_hw.c
View file

@ -344,11 +344,11 @@ int snd_rawmidi_hw_open(snd_rawmidi_t **inputp, snd_rawmidi_t **outputp,
sprintf(filename, SNDRV_FILE_RAWMIDI, card, device);
__again:
if (attempt++ > 3) {
snd_ctl_close(ctl);
return -EBUSY;
}
ret = snd_ctl_rawmidi_prefer_subdevice(ctl, subdevice);
if (attempt++ > 3) {
snd_ctl_close(ctl);
return -EBUSY;
}
ret = snd_ctl_rawmidi_prefer_subdevice(ctl, subdevice);
if (ret < 0) {
snd_ctl_close(ctl);
return ret;

194
src/seq/seq.c
View file

@ -58,12 +58,12 @@ A typical code would be like below:
// create a new client
snd_seq_t *open_client()
{
snd_seq_t *handle;
int err;
err = snd_seq_open(&handle, "default", SND_SEQ_OPEN_INPUT, 0);
if (err < 0)
return NULL;
snd_seq_set_client_name(handle, "My Client");
snd_seq_t *handle;
int err;
err = snd_seq_open(&handle, "default", SND_SEQ_OPEN_INPUT, 0);
if (err < 0)
return NULL;
snd_seq_set_client_name(handle, "My Client");
return handle;
}
\endcode
@ -138,13 +138,13 @@ Then, a connection from MIDI input port to this program is established.
From this time, events from keyboard are automatically sent to this program.
Timestamps will be updated according to the subscribed queue.
\code
MIDI input port (keyboard)
|
V
ALSA sequencer - update timestamp
|
V
application port
MIDI input port (keyboard)
|
V
ALSA sequencer - update timestamp
|
V
application port
\endcode
There is another subscription type for opposite direction:
@ -155,13 +155,13 @@ to MIDI port for write.
After this connection is established, events will be properly sent
to MIDI output device.
\code
application port
|
V
ALSA sequencer - events are scheduled
|
V
MIDI output port (WaveTable etc.)
application port
|
V
ALSA sequencer - events are scheduled
|
V
MIDI output port (WaveTable etc.)
\endcode
From the viewpoint of subscription, the examples above are special cases.
@ -178,13 +178,13 @@ The connection between ports can be done also by the "third" client.
Thus, filter applications have to manage
only input and output events regardless of receiver/sender addresses.
\code
sequencer port #1
|
V
ALSA sequencer (scheduled or real-time)
|
V
sequencer port #2
sequencer port #1
|
V
ALSA sequencer (scheduled or real-time)
|
V
sequencer port #2
\endcode
For the detail about subscription, see the section \ref seq_subs_more.
@ -454,11 +454,11 @@ For example, to set the tempo of the queue <code>q</code> to
\code
void set_tempo(snd_seq_t *handle, int queue)
{
snd_seq_queue_tempo_t *tempo;
snd_seq_queue_tempo_alloca(&tempo);
snd_seq_queue_tempo_set_tempo(tempo, 1000000); // 60 BPM
snd_seq_queue_tempo_set_ppq(tempo, 48); // 48 PPQ
snd_seq_set_queue_tempo(handle, queue, tempo);
snd_seq_queue_tempo_t *tempo;
snd_seq_queue_tempo_alloca(&tempo);
snd_seq_queue_tempo_set_tempo(tempo, 1000000); // 60 BPM
snd_seq_queue_tempo_set_ppq(tempo, 48); // 48 PPQ
snd_seq_set_queue_tempo(handle, queue, tempo);
}
\endcode
@ -629,19 +629,19 @@ The application port must have capability #SND_SEQ_PORT_CAP_WRITE.
\code
void capture_keyboard(snd_seq_t *seq)
{
snd_seq_addr_t sender, dest;
snd_seq_port_subscribe_t *subs;
sender.client = 64;
sender.port = 0;
dest.client = 128;
dest.port = 0;
snd_seq_port_subscribe_alloca(&subs);
snd_seq_port_subscribe_set_sender(subs, &sender);
snd_seq_port_subscribe_set_dest(subs, &dest);
snd_seq_port_subscribe_set_queue(subs, 1);
snd_seq_port_subscribe_set_time_update(subs, 1);
snd_seq_port_subscribe_set_time_real(subs, 1);
snd_seq_subscribe_port(seq, subs);
snd_seq_addr_t sender, dest;
snd_seq_port_subscribe_t *subs;
sender.client = 64;
sender.port = 0;
dest.client = 128;
dest.port = 0;
snd_seq_port_subscribe_alloca(&subs);
snd_seq_port_subscribe_set_sender(subs, &sender);
snd_seq_port_subscribe_set_dest(subs, &dest);
snd_seq_port_subscribe_set_queue(subs, 1);
snd_seq_port_subscribe_set_time_update(subs, 1);
snd_seq_port_subscribe_set_time_real(subs, 1);
snd_seq_subscribe_port(seq, subs);
}
\endcode
@ -652,23 +652,23 @@ The application port must have capability #SND_SEQ_PORT_CAP_READ.
\code
void subscribe_output(snd_seq_t *seq)
{
snd_seq_addr_t sender, dest;
snd_seq_port_subscribe_t *subs;
sender.client = 128;
sender.port = 0;
dest.client = 65;
dest.port = 1;
snd_seq_port_subscribe_alloca(&subs);
snd_seq_port_subscribe_set_sender(subs, &sender);
snd_seq_port_subscribe_set_dest(subs, &dest);
snd_seq_subscribe_port(seq, subs);
snd_seq_addr_t sender, dest;
snd_seq_port_subscribe_t *subs;
sender.client = 128;
sender.port = 0;
dest.client = 65;
dest.port = 1;
snd_seq_port_subscribe_alloca(&subs);
snd_seq_port_subscribe_set_sender(subs, &sender);
snd_seq_port_subscribe_set_dest(subs, &dest);
snd_seq_subscribe_port(seq, subs);
}
\endcode
This example can be simplified by using #snd_seq_connect_to() function.
\code
void subscribe_output(snd_seq_t *seq)
{
snd_seq_connect_to(seq, 0, 65, 1);
snd_seq_connect_to(seq, 0, 65, 1);
}
\endcode
@ -686,16 +686,16 @@ and the receiver
// ..in the third application (130:0) ..
void coupling(snd_seq_t *seq)
{
snd_seq_addr_t sender, dest;
snd_seq_port_subscribe_t *subs;
sender.client = 128;
sender.port = 0;
dest.client = 129;
dest.port = 0;
snd_seq_port_subscribe_alloca(&subs);
snd_seq_port_subscribe_set_sender(subs, &sender);
snd_seq_port_subscribe_set_dest(subs, &dest);
snd_seq_subscribe_port(seq, subs);
snd_seq_addr_t sender, dest;
snd_seq_port_subscribe_t *subs;
sender.client = 128;
sender.port = 0;
dest.client = 129;
dest.port = 0;
snd_seq_port_subscribe_alloca(&subs);
snd_seq_port_subscribe_set_sender(subs, &sender);
snd_seq_port_subscribe_set_dest(subs, &dest);
snd_seq_subscribe_port(seq, subs);
}
\endcode
@ -729,17 +729,17 @@ The program appears like this:
\code
void schedule_event(snd_seq_t *seq)
{
snd_seq_event_t ev;
snd_seq_event_t ev;
snd_seq_ev_clear(&ev);
snd_seq_ev_set_source(&ev, my_port);
snd_seq_ev_set_subs(&ev);
snd_seq_ev_schedule_tick(&ev, Q, 0, t);
... // set event type, data, so on..
snd_seq_ev_clear(&ev);
snd_seq_ev_set_source(&ev, my_port);
snd_seq_ev_set_subs(&ev);
snd_seq_ev_schedule_tick(&ev, Q, 0, t);
... // set event type, data, so on..
snd_seq_event_output(seq, &ev);
...
snd_seq_drain_output(seq); // if necessary
snd_seq_event_output(seq, &ev);
...
snd_seq_drain_output(seq); // if necessary
}
\endcode
Of course, you can use realtime stamp, too.
@ -754,16 +754,16 @@ The program can be more simplified as follows:
\code
void direct_delivery(snd_seq_t *seq)
{
snd_seq_event_t ev;
snd_seq_event_t ev;
snd_seq_ev_clear(&ev);
snd_seq_ev_set_source(&ev, port);
snd_seq_ev_set_subs(&ev);
snd_seq_ev_set_direct(&ev);
... // set event type, data, so on..
snd_seq_ev_clear(&ev);
snd_seq_ev_set_source(&ev, port);
snd_seq_ev_set_subs(&ev);
snd_seq_ev_set_direct(&ev);
... // set event type, data, so on..
snd_seq_event_output(seq, &ev);
snd_seq_drain_output(seq);
snd_seq_event_output(seq, &ev);
snd_seq_drain_output(seq);
}
\endcode
You should flush event soon after output event.
@ -778,15 +778,15 @@ after some modification, will appear as following:
\code
void event_filter(snd_seq_t *seq, snd_seq_event_t *ev)
{
while (snd_seq_event_input(seq, &ev) >= 0) {
//.. modify input event ..
while (snd_seq_event_input(seq, &ev) >= 0) {
//.. modify input event ..
snd_seq_ev_set_source(ev, my_port);
snd_seq_ev_set_subs(ev);
snd_seq_ev_set_direct(ev);
snd_seq_event_output(seq, ev);
snd_seq_drain_output(seq);
}
snd_seq_ev_set_source(ev, my_port);
snd_seq_ev_set_subs(ev);
snd_seq_ev_set_direct(ev);
snd_seq_event_output(seq, ev);
snd_seq_drain_output(seq);
}
}
\endcode
@ -1212,12 +1212,12 @@ int snd_seq_poll_descriptors(snd_seq_t *seq, struct pollfd *pfds, unsigned int s
*/
int snd_seq_poll_descriptors_revents(snd_seq_t *seq, struct pollfd *pfds, unsigned int nfds, unsigned short *revents)
{
assert(seq && pfds && revents);
if (nfds == 1) {
*revents = pfds->revents;
return 0;
}
return -EINVAL;
assert(seq && pfds && revents);
if (nfds == 1) {
*revents = pfds->revents;
return 0;
}
return -EINVAL;
}
/**

2
src/socket.c
View file

@ -60,7 +60,7 @@ int snd_send_fd(int sock, void *data, size_t len, int fd)
msghdr.msg_name = NULL;
msghdr.msg_namelen = 0;
msghdr.msg_iov = &vec;
msghdr.msg_iovlen = 1;
msghdr.msg_iovlen = 1;
msghdr.msg_control = cmsg;
msghdr.msg_controllen = cmsg_len;
msghdr.msg_flags = 0;

18
src/timer/timer.c
View file

@ -248,7 +248,7 @@ int snd_timer_open_lconf(snd_timer_t **timer, const char *name,
int snd_timer_close(snd_timer_t *timer)
{
int err;
assert(timer);
assert(timer);
while (!list_empty(&timer->async_handlers)) {
snd_async_handler_t *h = list_entry(timer->async_handlers.next, snd_async_handler_t, hlist);
snd_async_del_handler(h);
@ -388,12 +388,12 @@ int snd_timer_poll_descriptors(snd_timer_t *timer, struct pollfd *pfds, unsigned
*/
int snd_timer_poll_descriptors_revents(snd_timer_t *timer, struct pollfd *pfds, unsigned int nfds, unsigned short *revents)
{
assert(timer && pfds && revents);
if (nfds == 1) {
*revents = pfds->revents;
return 0;
}
return -EINVAL;
assert(timer && pfds && revents);
if (nfds == 1) {
*revents = pfds->revents;
return 0;
}
return -EINVAL;
}
/**
@ -428,8 +428,8 @@ int snd_timer_nonblock(snd_timer_t *timer, int nonblock)
int snd_timer_async(snd_timer_t *timer, int sig, pid_t pid)
{
assert(timer);
if (sig == 0)
sig = SIGIO;
if (sig == 0)
sig = SIGIO;
if (pid == 0)
pid = getpid();
return timer->ops->async(timer, sig, pid);

18
src/timer/timer_query.c
View file

@ -200,7 +200,7 @@ int snd_timer_query_open_lconf(snd_timer_query_t **timer, const char *name,
int snd_timer_query_close(snd_timer_query_t *timer)
{
int err;
assert(timer);
assert(timer);
err = timer->ops->close(timer);
if (timer->dl_handle)
snd_dlclose(timer->dl_handle);
@ -220,8 +220,8 @@ int snd_timer_query_close(snd_timer_query_t *timer)
*/
int snd_timer_query_next_device(snd_timer_query_t *timer, snd_timer_id_t *tid)
{
assert(timer);
assert(tid);
assert(timer);
assert(tid);
return timer->ops->next_device(timer, tid);
}
@ -389,8 +389,8 @@ EXPORT_SYMBOL int INTERNAL(snd_timer_query_info)(snd_timer_query_t *timer, snd_t
int snd_timer_query_info(snd_timer_query_t *timer, snd_timer_ginfo_t *info)
#endif
{
assert(timer);
assert(info);
assert(timer);
assert(info);
return timer->ops->info(timer, info);
}
use_default_symbol_version(__snd_timer_query_info, snd_timer_query_info, ALSA_0.9.0);
@ -407,8 +407,8 @@ EXPORT_SYMBOL int INTERNAL(snd_timer_query_params)(snd_timer_query_t *timer, snd
int snd_timer_query_params(snd_timer_query_t *timer, snd_timer_gparams_t *params)
#endif
{
assert(timer);
assert(params);
assert(timer);
assert(params);
return timer->ops->params(timer, params);
}
use_default_symbol_version(__snd_timer_query_params, snd_timer_query_params, ALSA_0.9.0);
@ -425,8 +425,8 @@ EXPORT_SYMBOL int INTERNAL(snd_timer_query_status)(snd_timer_query_t *timer, snd
int snd_timer_query_status(snd_timer_query_t *timer, snd_timer_gstatus_t *status)
#endif
{
assert(timer);
assert(status);
assert(timer);
assert(status);
return timer->ops->status(timer, status);
}
use_default_symbol_version(__snd_timer_query_status, snd_timer_query_status, ALSA_0.9.0);

4
src/topology/builder.c
View file

@ -13,8 +13,8 @@
GNU Lesser General Public License for more details.
Authors: Mengdong Lin <mengdong.lin@intel.com>
Yao Jin <yao.jin@intel.com>
Liam Girdwood <liam.r.girdwood@linux.intel.com>
Yao Jin <yao.jin@intel.com>
Liam Girdwood <liam.r.girdwood@linux.intel.com>
*/
#include "tplg_local.h"

4
src/topology/channel.c
View file

@ -13,8 +13,8 @@
GNU Lesser General Public License for more details.
Authors: Mengdong Lin <mengdong.lin@intel.com>
Yao Jin <yao.jin@intel.com>
Liam Girdwood <liam.r.girdwood@linux.intel.com>
Yao Jin <yao.jin@intel.com>
Liam Girdwood <liam.r.girdwood@linux.intel.com>
*/
#include "tplg_local.h"

4
src/topology/ctl.c
View file

@ -13,8 +13,8 @@
GNU Lesser General Public License for more details.
Authors: Mengdong Lin <mengdong.lin@intel.com>
Yao Jin <yao.jin@intel.com>
Liam Girdwood <liam.r.girdwood@linux.intel.com>
Yao Jin <yao.jin@intel.com>
Liam Girdwood <liam.r.girdwood@linux.intel.com>
*/
#include "tplg_local.h"

4
src/topology/dapm.c
View file

@ -13,8 +13,8 @@
GNU Lesser General Public License for more details.
Authors: Mengdong Lin <mengdong.lin@intel.com>
Yao Jin <yao.jin@intel.com>
Liam Girdwood <liam.r.girdwood@linux.intel.com>
Yao Jin <yao.jin@intel.com>
Liam Girdwood <liam.r.girdwood@linux.intel.com>
*/
#include "tplg_local.h"

6
src/topology/data.c
View file

@ -13,8 +13,8 @@
GNU Lesser General Public License for more details.
Authors: Mengdong Lin <mengdong.lin@intel.com>
Yao Jin <yao.jin@intel.com>
Liam Girdwood <liam.r.girdwood@linux.intel.com>
Yao Jin <yao.jin@intel.com>
Liam Girdwood <liam.r.girdwood@linux.intel.com>
*/
#include "tplg_local.h"
@ -413,7 +413,7 @@ static int write_hex(char *buf, char *str, int width)
long val;
void *p = &val;
errno = 0;
errno = 0;
if (safe_strtol_base(str, &val, 16) < 0)
return -EINVAL;

4
src/topology/elem.c
View file

@ -13,8 +13,8 @@
GNU Lesser General Public License for more details.
Authors: Mengdong Lin <mengdong.lin@intel.com>
Yao Jin <yao.jin@intel.com>
Liam Girdwood <liam.r.girdwood@linux.intel.com>
Yao Jin <yao.jin@intel.com>
Liam Girdwood <liam.r.girdwood@linux.intel.com>
*/
#include "tplg_local.h"

4
src/topology/ops.c
View file

@ -13,8 +13,8 @@
GNU Lesser General Public License for more details.
Authors: Mengdong Lin <mengdong.lin@intel.com>
Yao Jin <yao.jin@intel.com>
Liam Girdwood <liam.r.girdwood@linux.intel.com>
Yao Jin <yao.jin@intel.com>
Liam Girdwood <liam.r.girdwood@linux.intel.com>
*/
#include "tplg_local.h"

4
src/topology/parser.c
View file

@ -13,8 +13,8 @@
GNU Lesser General Public License for more details.
Authors: Mengdong Lin <mengdong.lin@intel.com>
Yao Jin <yao.jin@intel.com>
Liam Girdwood <liam.r.girdwood@linux.intel.com>
Yao Jin <yao.jin@intel.com>
Liam Girdwood <liam.r.girdwood@linux.intel.com>
*/
#include "tplg_local.h"

4
src/topology/pcm.c
View file

@ -13,8 +13,8 @@
GNU Lesser General Public License for more details.
Authors: Mengdong Lin <mengdong.lin@intel.com>
Yao Jin <yao.jin@intel.com>
Liam Girdwood <liam.r.girdwood@linux.intel.com>
Yao Jin <yao.jin@intel.com>
Liam Girdwood <liam.r.girdwood@linux.intel.com>
*/
#include "tplg_local.h"

4
src/topology/text.c
View file

@ -13,8 +13,8 @@
GNU Lesser General Public License for more details.
Authors: Mengdong Lin <mengdong.lin@intel.com>
Yao Jin <yao.jin@intel.com>
Liam Girdwood <liam.r.girdwood@linux.intel.com>
Yao Jin <yao.jin@intel.com>
Liam Girdwood <liam.r.girdwood@linux.intel.com>
*/

6
src/ucm/ucm_local.h
View file

@ -62,9 +62,9 @@
#define SEQUENCE_ELEMENT_TYPE_DEV_DISABLE_ALL 15
struct ucm_value {
struct list_head list;
char *name;
char *data;
struct list_head list;
char *name;
char *data;
};
/* sequence of a component device */

30
test/latency.c
View file

@ -251,9 +251,9 @@ int setparams(snd_pcm_t *phandle, snd_pcm_t *chandle, int *bufsize)
}
__again:
if (buffer_size > 0)
return -1;
if (last_bufsize == *bufsize)
if (buffer_size > 0)
return -1;
if (last_bufsize == *bufsize)
*bufsize += 4;
last_bufsize = *bufsize;
if (*bufsize > latency_max)
@ -282,8 +282,8 @@ int setparams(snd_pcm_t *phandle, snd_pcm_t *chandle, int *bufsize)
snd_pcm_hw_params_get_buffer_size(p_params, &p_size);
playback_buffer_size = p_size;
if (p_psize * 2 < p_size) {
snd_pcm_hw_params_get_periods_min(p_params, &val, NULL);
if (val > 2) {
snd_pcm_hw_params_get_periods_min(p_params, &val, NULL);
if (val > 2) {
printf("playback device does not support 2 periods per buffer\n");
exit(0);
}
@ -291,7 +291,7 @@ int setparams(snd_pcm_t *phandle, snd_pcm_t *chandle, int *bufsize)
}
snd_pcm_hw_params_get_buffer_size(c_params, &c_size);
if (c_psize * 2 < c_size) {
snd_pcm_hw_params_get_periods_min(c_params, &val, NULL);
snd_pcm_hw_params_get_periods_min(c_params, &val, NULL);
if (val > 2 ) {
printf("capture device does not support 2 periods per buffer\n");
exit(0);
@ -537,14 +537,14 @@ void help(void)
"-X,--realtime do a realtime check (buffering)\n"
"-O,--policy set scheduler policy (RR, FIFO or OTHER)\n"
);
printf("Recognized sample formats are:");
for (k = 0; k < SND_PCM_FORMAT_LAST; ++k) {
const char *s = snd_pcm_format_name(k);
if (s)
printf(" %s", s);
}
printf("\n\n");
printf(
printf("Recognized sample formats are:");
for (k = 0; k < SND_PCM_FORMAT_LAST; ++k) {
const char *s = snd_pcm_format_name(k);
if (s)
printf(" %s", s);
}
printf("\n\n");
printf(
"Tip #1 (usable latency with large periods, non-blocking mode, good CPU usage,\n"
" superb xrun prevention):\n"
" latency -m 8192 -M 8192 -t 1 -p\n"
@ -819,7 +819,7 @@ int main(int argc, char *argv[])
else {
if (effect)
applyeffect(buffer, r);
if (writebuf(phandle, buffer, r, &frames_out) < 0)
if (writebuf(phandle, buffer, r, &frames_out) < 0)
ok = 0;
}
}

14
test/midifile.c
View file

@ -370,8 +370,8 @@ readtrack (void) /* read a track chunk */
old_currtempo = Mf_currtempo;
old_realtime = Mf_realtime;
if (revised_time != tempo_change_time) {
old_f_realtime = Mf_f_realtime;
old_currtime = save_time;
old_f_realtime = Mf_f_realtime;
old_currtime = save_time;
}
delta_secs = mf_ticks2sec (revised_time-old_currtime, Mf_division, save_tempo);
#ifdef DEBUG_TIMES
@ -856,17 +856,17 @@ mf_write_track_chunk (int which_track, FILE *fp)
eputc(laststatus = meta_event);
eputc(end_of_track);
eputc(0);
eputc(0);
*/
/* It's impossible to know how long the track chunk will be beforehand,
so the position of the track length data is kept so that it can
be written after the chunk has been generated */
so the position of the track length data is kept so that it can
be written after the chunk has been generated */
place_marker = ftell (fp);
/* This method turned out not to be portable because the
parameter returned from ftell is not guaranteed to be
in bytes on every machine */
parameter returned from ftell is not guaranteed to be
in bytes on every machine */
/* track.length = place_marker - offset - (long) sizeof(track); */
#ifdef DEBUG

42
test/mixtest.c
View file

@ -92,30 +92,30 @@ void mix_areas_srv(unsigned int size,
{
src_step /= sizeof(*src);
sum_step /= sizeof(*sum);
while (size-- > 0) {
atomic_add(sum, *src);
src += src_step;
sum += sum_step;
}
while (size-- > 0) {
atomic_add(sum, *src);
src += src_step;
sum += sum_step;
}
}
void saturate(unsigned int size,
s16 *dst, const s32 *sum,
unsigned int dst_step, unsigned int sum_step)
s16 *dst, const s32 *sum,
unsigned int dst_step, unsigned int sum_step)
{
dst_step /= sizeof(*dst);
sum_step /= sizeof(*sum);
while (size-- > 0) {
s32 sample = *sum;
if (unlikely(sample < -0x8000))
*dst = -0x8000;
else if (unlikely(sample > 0x7fff))
*dst = 0x7fff;
else
*dst = sample;
dst += dst_step;
sum += sum_step;
}
while (size-- > 0) {
s32 sample = *sum;
if (unlikely(sample < -0x8000))
*dst = -0x8000;
else if (unlikely(sample > 0x7fff))
*dst = 0x7fff;
else
*dst = sample;
dst += dst_step;
sum += sum_step;
}
}
void mix_areas0(unsigned int size,
@ -226,16 +226,16 @@ int main(int argc, char **argv)
int LOOP = 100;
int i, t;
unsigned long long begin, end, diff, diffS, diff0, diff1, diff1_mmx, diff2;
double cpu_clock = detect_cpu_clock();
double cpu_clock = detect_cpu_clock();
s16 *dst = malloc(sizeof(*dst) * size);
s32 *sum = calloc(size, sizeof(*sum));
s16 **srcs = malloc(sizeof(*srcs) * n);
setscheduler();
#ifndef CONFIG_SMP
printf("CPU clock: %fMhz (UP)\n\n", cpu_clock / 10e5);
printf("CPU clock: %fMhz (UP)\n\n", cpu_clock / 10e5);
#else
printf("CPU clock: %fMhz (SMP)\n\n", cpu_clock / 10e5);
printf("CPU clock: %fMhz (SMP)\n\n", cpu_clock / 10e5);
#endif
if (argc > 3) {
size = atoi(argv[1]);

20
test/pcm.c
View file

@ -753,16 +753,16 @@ static void help(void)
"-n,--noresample do not resample\n"
"-e,--pevent enable poll event after each period\n"
"\n");
printf("Recognized sample formats are:");
for (k = 0; k < SND_PCM_FORMAT_LAST; ++k) {
const char *s = snd_pcm_format_name(k);
if (s)
printf(" %s", s);
}
printf("\n");
printf("Recognized transfer methods are:");
for (k = 0; transfer_methods[k].name; k++)
printf(" %s", transfer_methods[k].name);
printf("Recognized sample formats are:");
for (k = 0; k < SND_PCM_FORMAT_LAST; ++k) {
const char *s = snd_pcm_format_name(k);
if (s)
printf(" %s", s);
}
printf("\n");
printf("Recognized transfer methods are:");
for (k = 0; transfer_methods[k].name; k++)
printf(" %s", transfer_methods[k].name);
printf("\n");
}

2
test/pcm_min.c
View file

@ -32,7 +32,7 @@ int main(void)
exit(EXIT_FAILURE);
}
for (i = 0; i < 16; i++) {
for (i = 0; i < 16; i++) {
frames = snd_pcm_writei(handle, buffer, sizeof(buffer));
if (frames < 0)
frames = snd_pcm_recover(handle, frames, 0);

10
test/playmidi1.c
View file

@ -166,15 +166,15 @@ static void do_header(int format, int ntracks, int division)
snd_seq_queue_tempo_alloca(&tempo);
/* 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);
perror("get_queue_tempo");
exit(1);
}
if ((slave_ppq = snd_seq_queue_tempo_get_ppq(tempo)) != ppq) {
snd_seq_queue_tempo_set_ppq(tempo, ppq);
if (snd_seq_set_queue_tempo(seq_handle, dest_queue, tempo) < 0) {
perror("set_queue_tempo");
if (!slave && !shared_queue)
exit(1);
perror("set_queue_tempo");
if (!slave && !shared_queue)
exit(1);
else
printf("different PPQ %d in SMF from queue PPQ %d\n", ppq, slave_ppq);
} else

2
test/seq-sender.c
View file

@ -108,7 +108,7 @@ void event_sender_filter(snd_seq_t *handle)
}
void send_event(snd_seq_t *handle, int queue, int client, int port,
snd_seq_addr_t *dest, int *time)
snd_seq_addr_t *dest, int *time)
{
int err;
snd_seq_event_t ev;

14
test/seq.c
View file

@ -162,9 +162,9 @@ int main(int argc, char *argv[])
{"verbose", 0, NULL, HELPID_VERBOSE},
{"version", 0, NULL, HELPID_VERSION},
{NULL, 0, NULL, 0},
};
};
morehelp = 0;
morehelp = 0;
while (1) {
int c;
@ -193,10 +193,10 @@ int main(int argc, char *argv[])
morehelp++;
}
}
if (morehelp) {
help();
return 1;
}
if (morehelp) {
help();
return 1;
}
if (argc - optind <= 0) {
fprintf(stderr, "seq: Specify command...\n");
return 0;
@ -208,7 +208,7 @@ int main(int argc, char *argv[])
set_name(handle);
system_info(handle);
if (!strcmp(argv[optind], "system")) {
if (!strcmp(argv[optind], "system")) {
show_system_info(handle);
} else if (!strcmp(argv[optind], "queue")) {
arg = argc - optind > 1 ? atoi(argv[optind + 1]) : -1;

2
test/user-ctl-element-set.c
View file

@ -270,7 +270,7 @@ static int add_iec958_elem_set(struct elem_set_trial *trial,
err = snd_ctl_elem_add_iec958(trial->handle, trial->id);
if (err < 0)
return err;
return err;
/*
* In historical reason, the above API is not allowed to fill all of