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

Added snd_ prefix to mask and interval. Divided header.h wrappers

Browse source
This commit is contained in:
Abramo Bagnara 2001-01-30 16:51:26 +00:00
parent 9712a67778
commit 8712ffc6a5
28 changed files with 1122 additions and 1122 deletions
Download patch file Download diff file Expand all files Collapse all files

88
src/pcm/interval.c
View file

@ -19,8 +19,8 @@
*
*/
#define INTERVAL_C
#define INTERVAL_INLINE
#define SND_INTERVAL_C
#define SND_INTERVAL_INLINE
#include <sys/types.h>
#include <limits.h>
@ -105,10 +105,10 @@ static inline unsigned int muldiv32(unsigned int a, unsigned int b,
return n;
}
int interval_refine_min(interval_t *i, unsigned int min, int openmin)
int snd_interval_refine_min(snd_interval_t *i, unsigned int min, int openmin)
{
int changed = 0;
assert(!interval_empty(i));
assert(!snd_interval_empty(i));
if (i->min < min) {
i->min = min;
i->openmin = openmin;
@ -123,17 +123,17 @@ int interval_refine_min(interval_t *i, unsigned int min, int openmin)
i->openmin = 0;
}
}
if (interval_checkempty(i)) {
interval_none(i);
if (snd_interval_checkempty(i)) {
snd_interval_none(i);
return -EINVAL;
}
return changed;
}
int interval_refine_max(interval_t *i, unsigned int max, int openmax)
int snd_interval_refine_max(snd_interval_t *i, unsigned int max, int openmax)
{
int changed = 0;
assert(!interval_empty(i));
assert(!snd_interval_empty(i));
if (i->max > max) {
i->max = max;
i->openmax = openmax;
@ -148,18 +148,18 @@ int interval_refine_max(interval_t *i, unsigned int max, int openmax)
i->openmax = 0;
}
}
if (interval_checkempty(i)) {
interval_none(i);
if (snd_interval_checkempty(i)) {
snd_interval_none(i);
return -EINVAL;
}
return changed;
}
/* r <- v */
int interval_refine(interval_t *i, const interval_t *v)
int snd_interval_refine(snd_interval_t *i, const snd_interval_t *v)
{
int changed = 0;
assert(!interval_empty(i));
assert(!snd_interval_empty(i));
if (i->min < v->min) {
i->min = v->min;
i->openmin = v->openmin;
@ -191,17 +191,17 @@ int interval_refine(interval_t *i, const interval_t *v)
}
} else if (!i->openmin && !i->openmax && i->min == i->max)
i->integer = 1;
if (interval_checkempty(i)) {
interval_none(i);
if (snd_interval_checkempty(i)) {
snd_interval_none(i);
return -EINVAL;
}
return changed;
}
int interval_refine_first(interval_t *i)
int snd_interval_refine_first(snd_interval_t *i)
{
assert(!interval_empty(i));
if (interval_single(i))
assert(!snd_interval_empty(i));
if (snd_interval_single(i))
return 0;
i->max = i->min;
i->openmax = i->openmin;
@ -210,10 +210,10 @@ int interval_refine_first(interval_t *i)
return 1;
}
int interval_refine_last(interval_t *i)
int snd_interval_refine_last(snd_interval_t *i)
{
assert(!interval_empty(i));
if (interval_single(i))
assert(!snd_interval_empty(i));
if (snd_interval_single(i))
return 0;
i->min = i->max;
i->openmin = i->openmax;
@ -222,20 +222,20 @@ int interval_refine_last(interval_t *i)
return 1;
}
int interval_refine_set(interval_t *i, unsigned int val)
int snd_interval_refine_set(snd_interval_t *i, unsigned int val)
{
interval_t t;
snd_interval_t t;
t.empty = 0;
t.min = t.max = val;
t.openmin = t.openmax = 0;
t.integer = 1;
return interval_refine(i, &t);
return snd_interval_refine(i, &t);
}
void interval_add(const interval_t *a, const interval_t *b, interval_t *c)
void snd_interval_add(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c)
{
if (a->empty || b->empty) {
interval_none(c);
snd_interval_none(c);
return;
}
c->empty = 0;
@ -246,10 +246,10 @@ void interval_add(const interval_t *a, const interval_t *b, interval_t *c)
c->integer = (a->integer && b->integer);
}
void interval_sub(const interval_t *a, const interval_t *b, interval_t *c)
void snd_interval_sub(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c)
{
if (a->empty || b->empty) {
interval_none(c);
snd_interval_none(c);
return;
}
c->empty = 0;
@ -260,10 +260,10 @@ void interval_sub(const interval_t *a, const interval_t *b, interval_t *c)
c->integer = (a->integer && b->integer);
}
void interval_mul(const interval_t *a, const interval_t *b, interval_t *c)
void snd_interval_mul(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c)
{
if (a->empty || b->empty) {
interval_none(c);
snd_interval_none(c);
return;
}
c->empty = 0;
@ -274,11 +274,11 @@ void interval_mul(const interval_t *a, const interval_t *b, interval_t *c)
c->integer = (a->integer && b->integer);
}
void interval_div(const interval_t *a, const interval_t *b, interval_t *c)
void snd_interval_div(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c)
{
unsigned int r;
if (a->empty || b->empty) {
interval_none(c);
snd_interval_none(c);
return;
}
c->empty = 0;
@ -299,12 +299,12 @@ void interval_div(const interval_t *a, const interval_t *b, interval_t *c)
}
/* a * b / c */
void interval_muldiv(const interval_t *a, const interval_t *b,
const interval_t *c, interval_t *d)
void snd_interval_muldiv(const snd_interval_t *a, const snd_interval_t *b,
const snd_interval_t *c, snd_interval_t *d)
{
unsigned int r;
if (a->empty || b->empty || c->empty) {
interval_none(d);
snd_interval_none(d);
return;
}
d->empty = 0;
@ -320,12 +320,12 @@ void interval_muldiv(const interval_t *a, const interval_t *b,
}
/* a * b / k */
void interval_muldivk(const interval_t *a, const interval_t *b,
unsigned int k, interval_t *c)
void snd_interval_muldivk(const snd_interval_t *a, const snd_interval_t *b,
unsigned int k, snd_interval_t *c)
{
unsigned int r;
if (a->empty || b->empty) {
interval_none(c);
snd_interval_none(c);
return;
}
c->empty = 0;
@ -341,12 +341,12 @@ void interval_muldivk(const interval_t *a, const interval_t *b,
}
/* a * k / b */
void interval_mulkdiv(const interval_t *a, unsigned int k,
const interval_t *b, interval_t *c)
void snd_interval_mulkdiv(const snd_interval_t *a, unsigned int k,
const snd_interval_t *b, snd_interval_t *c)
{
unsigned int r;
if (a->empty || b->empty) {
interval_none(c);
snd_interval_none(c);
return;
}
c->empty = 0;
@ -366,15 +366,15 @@ void interval_mulkdiv(const interval_t *a, unsigned int k,
c->integer = 0;
}
void interval_print(const interval_t *i, snd_output_t *out)
void snd_interval_print(const snd_interval_t *i, snd_output_t *out)
{
if (interval_empty(i))
if (snd_interval_empty(i))
snd_output_printf(out, "NONE");
else if (i->min == 0 && i->openmin == 0 &&
i->max == UINT_MAX && i->openmax == 0)
snd_output_printf(out, "ALL");
else if (interval_single(i) && i->integer)
snd_output_printf(out, "%u", interval_value(i));
else if (snd_interval_single(i) && i->integer)
snd_output_printf(out, "%u", snd_interval_value(i));
else
snd_output_printf(out, "%c%u %u%c",
i->openmin ? '(' : '[',

64
src/pcm/interval.h
View file

@ -21,42 +21,42 @@
#include <stdio.h>
#ifdef INTERVAL_INLINE
#ifdef SND_INTERVAL_INLINE
#include "interval_inline.h"
#else
void interval_any(interval_t *i);
void interval_none(interval_t *i);
int interval_setinteger(interval_t *i);
int interval_empty(const interval_t *i);
int interval_single(const interval_t *i);
int interval_value(const interval_t *i);
int interval_min(const interval_t *i);
int interval_max(const interval_t *i);
int interval_test(const interval_t *i, unsigned int val);
void interval_copy(interval_t *dst, const interval_t *src);
void interval_floor(interval_t *i);
void interval_unfloor(interval_t *i);
int interval_always_eq(const interval_t *i1, const interval_t *i2);
int interval_never_eq(const interval_t *i1, const interval_t *i2);
void snd_interval_any(snd_interval_t *i);
void snd_interval_none(snd_interval_t *i);
int snd_interval_setinteger(snd_interval_t *i);
int snd_interval_empty(const snd_interval_t *i);
int snd_interval_single(const snd_interval_t *i);
int snd_interval_value(const snd_interval_t *i);
int snd_interval_min(const snd_interval_t *i);
int snd_interval_max(const snd_interval_t *i);
int snd_interval_test(const snd_interval_t *i, unsigned int val);
void snd_interval_copy(snd_interval_t *dst, const snd_interval_t *src);
void snd_interval_floor(snd_interval_t *i);
void snd_interval_unfloor(snd_interval_t *i);
int snd_interval_always_eq(const snd_interval_t *i1, const snd_interval_t *i2);
int snd_interval_never_eq(const snd_interval_t *i1, const snd_interval_t *i2);
#endif
void interval_add(const interval_t *a, const interval_t *b, interval_t *c);
void interval_sub(const interval_t *a, const interval_t *b, interval_t *c);
void interval_mul(const interval_t *a, const interval_t *b, interval_t *c);
void interval_div(const interval_t *a, const interval_t *b, interval_t *c);
void interval_muldiv(const interval_t *a, const interval_t *b,
const interval_t *c, interval_t *d);
void interval_muldivk(const interval_t *a, const interval_t *b,
unsigned int k, interval_t *c);
void interval_mulkdiv(const interval_t *a, unsigned int k,
const interval_t *b, interval_t *c);
void interval_print(const interval_t *i, snd_output_t *out);
int interval_refine_min(interval_t *i, unsigned int min, int openmin);
int interval_refine_max(interval_t *i, unsigned int max, int openmax);
int interval_refine(interval_t *i, const interval_t *v);
int interval_refine_first(interval_t *i);
int interval_refine_last(interval_t *i);
int interval_refine_set(interval_t *i, unsigned int val);
void snd_interval_add(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c);
void snd_interval_sub(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c);
void snd_interval_mul(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c);
void snd_interval_div(const snd_interval_t *a, const snd_interval_t *b, snd_interval_t *c);
void snd_interval_muldiv(const snd_interval_t *a, const snd_interval_t *b,
const snd_interval_t *c, snd_interval_t *d);
void snd_interval_muldivk(const snd_interval_t *a, const snd_interval_t *b,
unsigned int k, snd_interval_t *c);
void snd_interval_mulkdiv(const snd_interval_t *a, unsigned int k,
const snd_interval_t *b, snd_interval_t *c);
void snd_interval_print(const snd_interval_t *i, snd_output_t *out);
int snd_interval_refine_min(snd_interval_t *i, unsigned int min, int openmin);
int snd_interval_refine_max(snd_interval_t *i, unsigned int max, int openmax);
int snd_interval_refine(snd_interval_t *i, const snd_interval_t *v);
int snd_interval_refine_first(snd_interval_t *i);
int snd_interval_refine_last(snd_interval_t *i);
int snd_interval_refine_set(snd_interval_t *i, unsigned int val);
void boundary_sub(int a, int adir, int b, int bdir, int *c, int *cdir);
int boundary_lt(unsigned int a, int adir, unsigned int b, int bdir);
int boundary_nearer(int min, int mindir, int best, int bestdir, int max, int maxdir);

48
src/pcm/interval_inline.h
View file

@ -19,13 +19,13 @@
*
*/
#ifdef INTERVAL_C
#ifdef SND_INTERVAL_C
#define INLINE inline
#else
#define INLINE extern inline
#endif
INLINE void interval_any(interval_t *i)
INLINE void snd_interval_any(snd_interval_t *i)
{
i->min = 0;
i->openmin = 0;
@ -35,59 +35,59 @@ INLINE void interval_any(interval_t *i)
i->empty = 0;
}
INLINE void interval_none(interval_t *i)
INLINE void snd_interval_none(snd_interval_t *i)
{
i->empty = 1;
}
INLINE int interval_checkempty(const interval_t *i)
INLINE int snd_interval_checkempty(const snd_interval_t *i)
{
return (i->min > i->max ||
(i->min == i->max && (i->openmin || i->openmax)));
}
INLINE int interval_empty(const interval_t *i)
INLINE int snd_interval_empty(const snd_interval_t *i)
{
return i->empty;
}
INLINE int interval_single(const interval_t *i)
INLINE int snd_interval_single(const snd_interval_t *i)
{
assert(!interval_empty(i));
assert(!snd_interval_empty(i));
return (i->min == i->max ||
(i->min + 1 == i->max && i->openmax));
}
INLINE int interval_value(const interval_t *i)
INLINE int snd_interval_value(const snd_interval_t *i)
{
assert(interval_single(i));
assert(snd_interval_single(i));
return i->min;
}
INLINE int interval_min(const interval_t *i)
INLINE int snd_interval_min(const snd_interval_t *i)
{
assert(!interval_empty(i));
assert(!snd_interval_empty(i));
return i->min;
}
INLINE int interval_max(const interval_t *i)
INLINE int snd_interval_max(const snd_interval_t *i)
{
assert(!interval_empty(i));
assert(!snd_interval_empty(i));
return i->max;
}
INLINE int interval_test(const interval_t *i, unsigned int val)
INLINE int snd_interval_test(const snd_interval_t *i, unsigned int val)
{
return !((i->min > val || (i->min == val && i->openmin) ||
i->max < val || (i->max == val && i->openmax)));
}
INLINE void interval_copy(interval_t *d, const interval_t *s)
INLINE void snd_interval_copy(snd_interval_t *d, const snd_interval_t *s)
{
*d = *s;
}
INLINE int interval_setinteger(interval_t *i)
INLINE int snd_interval_setinteger(snd_interval_t *i)
{
if (i->integer)
return 0;
@ -97,9 +97,9 @@ INLINE int interval_setinteger(interval_t *i)
return 1;
}
INLINE void interval_floor(interval_t *i)
INLINE void snd_interval_floor(snd_interval_t *i)
{
if (i->integer || interval_empty(i))
if (i->integer || snd_interval_empty(i))
return;
i->openmin = 0;
if (i->openmax) {
@ -109,9 +109,9 @@ INLINE void interval_floor(interval_t *i)
i->integer = 1;
}
INLINE void interval_unfloor(interval_t *i)
INLINE void snd_interval_unfloor(snd_interval_t *i)
{
if (interval_empty(i))
if (snd_interval_empty(i))
return;
if (i->max == UINT_MAX)
return;
@ -123,13 +123,13 @@ INLINE void interval_unfloor(interval_t *i)
}
INLINE int interval_always_eq(const interval_t *i1, const interval_t *i2)
INLINE int snd_interval_always_eq(const snd_interval_t *i1, const snd_interval_t *i2)
{
return interval_single(i1) && interval_single(i2) &&
interval_value(i1) == interval_value(i2);
return snd_interval_single(i1) && snd_interval_single(i2) &&
snd_interval_value(i1) == snd_interval_value(i2);
}
INLINE int interval_never_eq(const interval_t *i1, const interval_t *i2)
INLINE int snd_interval_never_eq(const snd_interval_t *i1, const snd_interval_t *i2)
{
return (i1->max < i2->min ||

4
src/pcm/mask.c
View file

@ -19,8 +19,8 @@
*
*/
#define MASK_C
#define MASK_INLINE
#define SND_MASK_C
#define SND_MASK_INLINE
#include <sys/types.h>
#include <limits.h>

60
src/pcm/mask.h
View file

@ -25,37 +25,37 @@
#include <assert.h>
#include "asoundlib.h"
#define MASK_MAX 31
#define SND_MASK_MAX 31
#ifdef MASK_INLINE
#ifdef SND_MASK_INLINE
#include "mask_inline.h"
#else
void mask_none(mask_t *mask);
void mask_any(mask_t *mask);
void mask_load(mask_t *mask, unsigned int msk);
int mask_empty(const mask_t *mask);
int mask_full(const mask_t *mask);
void mask_set(mask_t *mask, unsigned int val);
void mask_reset(mask_t *mask, unsigned int val);
void mask_copy(mask_t *mask, const mask_t *v);
int mask_test(const mask_t *mask, unsigned int val);
void mask_intersect(mask_t *mask, const mask_t *v);
void mask_union(mask_t *mask, const mask_t *v);
unsigned int mask_count(const mask_t *mask);
unsigned int mask_min(const mask_t *mask);
unsigned int mask_max(const mask_t *mask);
void mask_set_range(mask_t *mask, unsigned int from, unsigned int to);
void mask_reset_range(mask_t *mask, unsigned int from, unsigned int to);
void mask_leave(mask_t *mask, unsigned int val);
int mask_eq(const mask_t *mask, const mask_t *v);
int mask_single(const mask_t *mask);
int mask_refine(mask_t *mask, const mask_t *v);
int mask_refine_first(mask_t *mask);
int mask_refine_last(mask_t *mask);
int mask_refine_min(mask_t *mask, unsigned int val);
int mask_refine_max(mask_t *mask, unsigned int val);
int mask_refine_set(mask_t *mask, unsigned int val);
int mask_value(const mask_t *mask);
int mask_always_eq(const mask_t *m1, const mask_t *m2);
int mask_never_eq(const mask_t *m1, const mask_t *m2);
void snd_mask_none(snd_mask_t *mask);
void snd_mask_any(snd_mask_t *mask);
void snd_mask_load(snd_mask_t *mask, unsigned int msk);
int snd_mask_empty(const snd_mask_t *mask);
int snd_mask_full(const snd_mask_t *mask);
void snd_mask_set(snd_mask_t *mask, unsigned int val);
void snd_mask_reset(snd_mask_t *mask, unsigned int val);
void snd_mask_copy(snd_mask_t *mask, const snd_mask_t *v);
int snd_mask_test(const snd_mask_t *mask, unsigned int val);
void snd_mask_intersect(snd_mask_t *mask, const snd_mask_t *v);
void snd_mask_union(snd_mask_t *mask, const snd_mask_t *v);
unsigned int snd_mask_count(const snd_mask_t *mask);
unsigned int snd_mask_min(const snd_mask_t *mask);
unsigned int snd_mask_max(const snd_mask_t *mask);
void snd_mask_set_range(snd_mask_t *mask, unsigned int from, unsigned int to);
void snd_mask_reset_range(snd_mask_t *mask, unsigned int from, unsigned int to);
void snd_mask_leave(snd_mask_t *mask, unsigned int val);
int snd_mask_eq(const snd_mask_t *mask, const snd_mask_t *v);
int snd_mask_single(const snd_mask_t *mask);
int snd_mask_refine(snd_mask_t *mask, const snd_mask_t *v);
int snd_mask_refine_first(snd_mask_t *mask);
int snd_mask_refine_last(snd_mask_t *mask);
int snd_mask_refine_min(snd_mask_t *mask, unsigned int val);
int snd_mask_refine_max(snd_mask_t *mask, unsigned int val);
int snd_mask_refine_set(snd_mask_t *mask, unsigned int val);
int snd_mask_value(const snd_mask_t *mask);
int snd_mask_always_eq(const snd_mask_t *m1, const snd_mask_t *m2);
int snd_mask_never_eq(const snd_mask_t *m1, const snd_mask_t *m2);
#endif

180
src/pcm/mask_inline.h
View file

@ -22,7 +22,7 @@
#include <sys/types.h>
#include <assert.h>
#ifdef MASK_C
#ifdef SND_MASK_C
#define INLINE inline
#else
#define INLINE extern inline
@ -32,11 +32,11 @@
#define MASK_MAX 31
#endif
struct _mask {
struct _snd_mask {
unsigned int bits;
};
#define mask_bits(mask) ((mask)->bits)
#define snd_mask_bits(mask) ((mask)->bits)
INLINE unsigned int ld2(u_int32_t v)
{
@ -72,190 +72,190 @@ INLINE unsigned int hweight32(u_int32_t v)
return (v & 0x0000FFFF) + ((v >> 16) & 0x0000FFFF);
}
INLINE size_t mask_sizeof(void)
INLINE size_t snd_mask_sizeof(void)
{
return sizeof(mask_t);
return sizeof(snd_mask_t);
}
INLINE void mask_none(mask_t *mask)
INLINE void snd_mask_none(snd_mask_t *mask)
{
mask_bits(mask) = 0;
snd_mask_bits(mask) = 0;
}
INLINE void mask_any(mask_t *mask)
INLINE void snd_mask_any(snd_mask_t *mask)
{
mask_bits(mask) = ~0U;
snd_mask_bits(mask) = ~0U;
}
INLINE void mask_load(mask_t *mask, unsigned int msk)
INLINE void snd_mask_load(snd_mask_t *mask, unsigned int msk)
{
mask_bits(mask) = msk;
snd_mask_bits(mask) = msk;
}
INLINE int mask_empty(const mask_t *mask)
INLINE int snd_mask_empty(const snd_mask_t *mask)
{
return mask_bits(mask) == 0;
return snd_mask_bits(mask) == 0;
}
INLINE int mask_full(const mask_t *mask)
INLINE int snd_mask_full(const snd_mask_t *mask)
{
return mask_bits(mask) == ~0U;
return snd_mask_bits(mask) == ~0U;
}
INLINE unsigned int mask_count(const mask_t *mask)
INLINE unsigned int snd_mask_count(const snd_mask_t *mask)
{
return hweight32(mask_bits(mask));
return hweight32(snd_mask_bits(mask));
}
INLINE unsigned int mask_min(const mask_t *mask)
INLINE unsigned int snd_mask_min(const snd_mask_t *mask)
{
assert(!mask_empty(mask));
return ffs(mask_bits(mask)) - 1;
assert(!snd_mask_empty(mask));
return ffs(snd_mask_bits(mask)) - 1;
}
INLINE unsigned int mask_max(const mask_t *mask)
INLINE unsigned int snd_mask_max(const snd_mask_t *mask)
{
assert(!mask_empty(mask));
return ld2(mask_bits(mask));
assert(!snd_mask_empty(mask));
return ld2(snd_mask_bits(mask));
}
INLINE void mask_set(mask_t *mask, unsigned int val)
INLINE void snd_mask_set(snd_mask_t *mask, unsigned int val)
{
assert(val <= MASK_MAX);
mask_bits(mask) |= (1U << val);
assert(val <= SND_MASK_MAX);
snd_mask_bits(mask) |= (1U << val);
}
INLINE void mask_reset(mask_t *mask, unsigned int val)
INLINE void snd_mask_reset(snd_mask_t *mask, unsigned int val)
{
assert(val <= MASK_MAX);
mask_bits(mask) &= ~(1U << val);
assert(val <= SND_MASK_MAX);
snd_mask_bits(mask) &= ~(1U << val);
}
INLINE void mask_set_range(mask_t *mask, unsigned int from, unsigned int to)
INLINE void snd_mask_set_range(snd_mask_t *mask, unsigned int from, unsigned int to)
{
assert(to <= MASK_MAX && from <= to);
mask_bits(mask) |= ((1U << (from - to + 1)) - 1) << from;
assert(to <= SND_MASK_MAX && from <= to);
snd_mask_bits(mask) |= ((1U << (from - to + 1)) - 1) << from;
}
INLINE void mask_reset_range(mask_t *mask, unsigned int from, unsigned int to)
INLINE void snd_mask_reset_range(snd_mask_t *mask, unsigned int from, unsigned int to)
{
assert(to <= MASK_MAX && from <= to);
mask_bits(mask) &= ~(((1U << (from - to + 1)) - 1) << from);
assert(to <= SND_MASK_MAX && from <= to);
snd_mask_bits(mask) &= ~(((1U << (from - to + 1)) - 1) << from);
}
INLINE void mask_leave(mask_t *mask, unsigned int val)
INLINE void snd_mask_leave(snd_mask_t *mask, unsigned int val)
{
assert(val <= MASK_MAX);
mask_bits(mask) &= 1U << val;
assert(val <= SND_MASK_MAX);
snd_mask_bits(mask) &= 1U << val;
}
INLINE void mask_intersect(mask_t *mask, const mask_t *v)
INLINE void snd_mask_intersect(snd_mask_t *mask, const snd_mask_t *v)
{
mask_bits(mask) &= mask_bits(v);
snd_mask_bits(mask) &= snd_mask_bits(v);
}
INLINE void mask_union(mask_t *mask, const mask_t *v)
INLINE void snd_mask_union(snd_mask_t *mask, const snd_mask_t *v)
{
mask_bits(mask) |= mask_bits(v);
snd_mask_bits(mask) |= snd_mask_bits(v);
}
INLINE int mask_eq(const mask_t *mask, const mask_t *v)
INLINE int snd_mask_eq(const snd_mask_t *mask, const snd_mask_t *v)
{
return mask_bits(mask) == mask_bits(v);
return snd_mask_bits(mask) == snd_mask_bits(v);
}
INLINE void mask_copy(mask_t *mask, const mask_t *v)
INLINE void snd_mask_copy(snd_mask_t *mask, const snd_mask_t *v)
{
mask_bits(mask) = mask_bits(v);
snd_mask_bits(mask) = snd_mask_bits(v);
}
INLINE int mask_test(const mask_t *mask, unsigned int val)
INLINE int snd_mask_test(const snd_mask_t *mask, unsigned int val)
{
assert(val <= MASK_MAX);
return mask_bits(mask) & (1U << val);
assert(val <= SND_MASK_MAX);
return snd_mask_bits(mask) & (1U << val);
}
INLINE int mask_single(const mask_t *mask)
INLINE int snd_mask_single(const snd_mask_t *mask)
{
assert(!mask_empty(mask));
return !(mask_bits(mask) & (mask_bits(mask) - 1));
assert(!snd_mask_empty(mask));
return !(snd_mask_bits(mask) & (snd_mask_bits(mask) - 1));
}
INLINE int mask_refine(mask_t *mask, const mask_t *v)
INLINE int snd_mask_refine(snd_mask_t *mask, const snd_mask_t *v)
{
mask_t old;
assert(!mask_empty(mask));
mask_copy(&old, mask);
mask_intersect(mask, v);
if (mask_empty(mask))
snd_mask_t old;
assert(!snd_mask_empty(mask));
snd_mask_copy(&old, mask);
snd_mask_intersect(mask, v);
if (snd_mask_empty(mask))
return -EINVAL;
return !mask_eq(mask, &old);
return !snd_mask_eq(mask, &old);
}
INLINE int mask_refine_first(mask_t *mask)
INLINE int snd_mask_refine_first(snd_mask_t *mask)
{
assert(!mask_empty(mask));
if (mask_single(mask))
assert(!snd_mask_empty(mask));
if (snd_mask_single(mask))
return 0;
mask_leave(mask, mask_min(mask));
snd_mask_leave(mask, snd_mask_min(mask));
return 1;
}
INLINE int mask_refine_last(mask_t *mask)
INLINE int snd_mask_refine_last(snd_mask_t *mask)
{
assert(!mask_empty(mask));
if (mask_single(mask))
assert(!snd_mask_empty(mask));
if (snd_mask_single(mask))
return 0;
mask_leave(mask, mask_max(mask));
snd_mask_leave(mask, snd_mask_max(mask));
return 1;
}
INLINE int mask_refine_min(mask_t *mask, unsigned int val)
INLINE int snd_mask_refine_min(snd_mask_t *mask, unsigned int val)
{
assert(!mask_empty(mask));
if (mask_min(mask) >= val)
assert(!snd_mask_empty(mask));
if (snd_mask_min(mask) >= val)
return 0;
mask_reset_range(mask, 0, val - 1);
if (mask_empty(mask))
snd_mask_reset_range(mask, 0, val - 1);
if (snd_mask_empty(mask))
return -EINVAL;
return 1;
}
INLINE int mask_refine_max(mask_t *mask, unsigned int val)
INLINE int snd_mask_refine_max(snd_mask_t *mask, unsigned int val)
{
assert(!mask_empty(mask));
if (mask_max(mask) <= val)
assert(!snd_mask_empty(mask));
if (snd_mask_max(mask) <= val)
return 0;
mask_reset_range(mask, val + 1, MASK_MAX);
if (mask_empty(mask))
snd_mask_reset_range(mask, val + 1, SND_MASK_MAX);
if (snd_mask_empty(mask))
return -EINVAL;
return 1;
}
INLINE int mask_refine_set(mask_t *mask, unsigned int val)
INLINE int snd_mask_refine_set(snd_mask_t *mask, unsigned int val)
{
int changed;
assert(!mask_empty(mask));
changed = !mask_single(mask);
mask_leave(mask, val);
if (mask_empty(mask))
assert(!snd_mask_empty(mask));
changed = !snd_mask_single(mask);
snd_mask_leave(mask, val);
if (snd_mask_empty(mask))
return -EINVAL;
return changed;
}
INLINE int mask_value(const mask_t *mask)
INLINE int snd_mask_value(const snd_mask_t *mask)
{
assert(!mask_empty(mask));
return mask_min(mask);
assert(!snd_mask_empty(mask));
return snd_mask_min(mask);
}
INLINE int mask_always_eq(const mask_t *m1, const mask_t *m2)
INLINE int snd_mask_always_eq(const snd_mask_t *m1, const snd_mask_t *m2)
{
return mask_single(m1) && mask_single(m2) &&
mask_value(m1) == mask_value(m2);
return snd_mask_single(m1) && snd_mask_single(m2) &&
snd_mask_value(m1) == snd_mask_value(m2);
}
INLINE int mask_never_eq(const mask_t *m1, const mask_t *m2)
INLINE int snd_mask_never_eq(const snd_mask_t *m1, const snd_mask_t *m2)
{
return (mask_bits(m1) & mask_bits(m2)) == 0;
return (snd_mask_bits(m1) & snd_mask_bits(m2)) == 0;
}

12
src/pcm/pcm_adpcm.c
View file

@ -316,15 +316,15 @@ static int snd_pcm_adpcm_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t
{
snd_pcm_adpcm_t *adpcm = pcm->private;
int err;
mask_t *access_mask = alloca(mask_sizeof());
mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN);
snd_mask_t *access_mask = alloca(snd_mask_sizeof());
snd_mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN);
err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS,
access_mask);
if (err < 0)
return err;
if (adpcm->sformat == SND_PCM_FORMAT_IMA_ADPCM) {
mask_t *format_mask = alloca(mask_sizeof());
mask_load(format_mask, SND_PCM_FMTBIT_LINEAR);
snd_mask_t *format_mask = alloca(snd_mask_sizeof());
snd_mask_load(format_mask, SND_PCM_FMTBIT_LINEAR);
err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_FORMAT,
format_mask);
} else {
@ -345,8 +345,8 @@ static int snd_pcm_adpcm_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t
static int snd_pcm_adpcm_hw_refine_sprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *sparams)
{
snd_pcm_adpcm_t *adpcm = pcm->private;
mask_t *saccess_mask = alloca(mask_sizeof());
mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
snd_mask_t *saccess_mask = alloca(snd_mask_sizeof());
snd_mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
_snd_pcm_hw_params_any(sparams);
_snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
saccess_mask);

12
src/pcm/pcm_alaw.c
View file

@ -215,15 +215,15 @@ static int snd_pcm_alaw_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *
{
snd_pcm_alaw_t *alaw = pcm->private;
int err;
mask_t *access_mask = alloca(mask_sizeof());
mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN);
snd_mask_t *access_mask = alloca(snd_mask_sizeof());
snd_mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN);
err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS,
access_mask);
if (err < 0)
return err;
if (alaw->sformat == SND_PCM_FORMAT_A_LAW) {
mask_t *format_mask = alloca(mask_sizeof());
mask_load(format_mask, SND_PCM_FMTBIT_LINEAR);
snd_mask_t *format_mask = alloca(snd_mask_sizeof());
snd_mask_load(format_mask, SND_PCM_FMTBIT_LINEAR);
err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_FORMAT,
format_mask);
} else {
@ -244,8 +244,8 @@ static int snd_pcm_alaw_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *
static int snd_pcm_alaw_hw_refine_sprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *sparams)
{
snd_pcm_alaw_t *alaw = pcm->private;
mask_t *saccess_mask = alloca(mask_sizeof());
mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
snd_mask_t *saccess_mask = alloca(snd_mask_sizeof());
snd_mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
_snd_pcm_hw_params_any(sparams);
_snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
saccess_mask);

8
src/pcm/pcm_copy.c
View file

@ -31,8 +31,8 @@ typedef struct {
static int snd_pcm_copy_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *params)
{
int err;
mask_t *access_mask = alloca(mask_sizeof());
mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN);
snd_mask_t *access_mask = alloca(snd_mask_sizeof());
snd_mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN);
err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS,
access_mask);
if (err < 0)
@ -43,8 +43,8 @@ static int snd_pcm_copy_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_
static int snd_pcm_copy_hw_refine_sprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *sparams)
{
mask_t *saccess_mask = alloca(mask_sizeof());
mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
snd_mask_t *saccess_mask = alloca(snd_mask_sizeof());
snd_mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
_snd_pcm_hw_params_any(sparams);
_snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
saccess_mask);

16
src/pcm/pcm_hw.c
View file

@ -44,8 +44,8 @@
typedef struct {
int fd;
int card, device, subdevice;
volatile snd_pcm_mmap_status_t *mmap_status;
snd_pcm_mmap_control_t *mmap_control;
volatile struct sndrv_pcm_mmap_status *mmap_status;
struct sndrv_pcm_mmap_control *mmap_control;
int shmid;
} snd_pcm_hw_t;
@ -318,7 +318,7 @@ static snd_pcm_sframes_t snd_pcm_hw_writei(snd_pcm_t *pcm, const void *buffer, s
snd_pcm_sframes_t result;
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
snd_xferi_t xferi;
struct sndrv_xferi xferi;
xferi.buf = (char*) buffer;
xferi.frames = size;
result = ioctl(fd, SNDRV_PCM_IOCTL_WRITEI_FRAMES, &xferi);
@ -332,7 +332,7 @@ static snd_pcm_sframes_t snd_pcm_hw_writen(snd_pcm_t *pcm, void **bufs, snd_pcm_
snd_pcm_sframes_t result;
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
snd_xfern_t xfern;
struct sndrv_xfern xfern;
xfern.bufs = bufs;
xfern.frames = size;
result = ioctl(fd, SNDRV_PCM_IOCTL_WRITEN_FRAMES, &xfern);
@ -346,7 +346,7 @@ static snd_pcm_sframes_t snd_pcm_hw_readi(snd_pcm_t *pcm, void *buffer, snd_pcm_
snd_pcm_sframes_t result;
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
snd_xferi_t xferi;
struct sndrv_xferi xferi;
xferi.buf = buffer;
xferi.frames = size;
result = ioctl(fd, SNDRV_PCM_IOCTL_READI_FRAMES, &xferi);
@ -360,7 +360,7 @@ snd_pcm_sframes_t snd_pcm_hw_readn(snd_pcm_t *pcm, void **bufs, snd_pcm_uframes_
snd_pcm_sframes_t result;
snd_pcm_hw_t *hw = pcm->private;
int fd = hw->fd;
snd_xfern_t xfern;
struct sndrv_xfern xfern;
xfern.bufs = bufs;
xfern.frames = size;
result = ioctl(fd, SNDRV_PCM_IOCTL_READN_FRAMES, &xfern);
@ -373,7 +373,7 @@ static int snd_pcm_hw_mmap_status(snd_pcm_t *pcm)
{
snd_pcm_hw_t *hw = pcm->private;
void *ptr;
ptr = mmap(NULL, PAGE_ALIGN(sizeof(snd_pcm_mmap_status_t)), PROT_READ, MAP_FILE|MAP_SHARED,
ptr = mmap(NULL, PAGE_ALIGN(sizeof(struct sndrv_pcm_mmap_status)), PROT_READ, MAP_FILE|MAP_SHARED,
hw->fd, SND_PCM_MMAP_OFFSET_STATUS);
if (ptr == MAP_FAILED || ptr == NULL) {
SYSERR("status mmap failed");
@ -388,7 +388,7 @@ static int snd_pcm_hw_mmap_control(snd_pcm_t *pcm)
{
snd_pcm_hw_t *hw = pcm->private;
void *ptr;
ptr = mmap(NULL, PAGE_ALIGN(sizeof(snd_pcm_mmap_control_t)), PROT_READ|PROT_WRITE, MAP_FILE|MAP_SHARED,
ptr = mmap(NULL, PAGE_ALIGN(sizeof(struct sndrv_pcm_mmap_control)), PROT_READ|PROT_WRITE, MAP_FILE|MAP_SHARED,
hw->fd, SND_PCM_MMAP_OFFSET_CONTROL);
if (ptr == MAP_FAILED || ptr == NULL) {
SYSERR("control mmap failed");

12
src/pcm/pcm_linear.c
View file

@ -132,10 +132,10 @@ void snd_pcm_linear_convert(const snd_pcm_channel_area_t *src_areas, snd_pcm_ufr
static int snd_pcm_linear_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *params)
{
int err;
mask_t *access_mask = alloca(mask_sizeof());
mask_t *format_mask = alloca(mask_sizeof());
mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN);
mask_load(format_mask, SND_PCM_FMTBIT_LINEAR);
snd_mask_t *access_mask = alloca(snd_mask_sizeof());
snd_mask_t *format_mask = alloca(snd_mask_sizeof());
snd_mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN);
snd_mask_load(format_mask, SND_PCM_FMTBIT_LINEAR);
err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS,
access_mask);
if (err < 0)
@ -155,8 +155,8 @@ static int snd_pcm_linear_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, sn
static int snd_pcm_linear_hw_refine_sprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *sparams)
{
snd_pcm_linear_t *linear = pcm->private;
mask_t *saccess_mask = alloca(mask_sizeof());
mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
snd_mask_t *saccess_mask = alloca(snd_mask_sizeof());
snd_mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
_snd_pcm_hw_params_any(sparams);
_snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
saccess_mask);

4
src/pcm/pcm_local.h
View file

@ -332,9 +332,9 @@ void _snd_pcm_hw_param_setempty(snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var);
int _snd_pcm_hw_param_refine_interval(snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var,
const interval_t *val);
const snd_interval_t *val);
int _snd_pcm_hw_param_mask(snd_pcm_hw_params_t *params,
unsigned int var, const mask_t *mask);
unsigned int var, const snd_mask_t *mask);
int _snd_pcm_hw_param_first(snd_pcm_hw_params_t *params,
unsigned int var);
int _snd_pcm_hw_param_last(snd_pcm_hw_params_t *params,

12
src/pcm/pcm_mulaw.c
View file

@ -232,15 +232,15 @@ static int snd_pcm_mulaw_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t
{
snd_pcm_mulaw_t *mulaw = pcm->private;
int err;
mask_t *access_mask = alloca(mask_sizeof());
mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN);
snd_mask_t *access_mask = alloca(snd_mask_sizeof());
snd_mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN);
err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS,
access_mask);
if (err < 0)
return err;
if (mulaw->sformat == SND_PCM_FORMAT_MU_LAW) {
mask_t *format_mask = alloca(mask_sizeof());
mask_load(format_mask, SND_PCM_FMTBIT_LINEAR);
snd_mask_t *format_mask = alloca(snd_mask_sizeof());
snd_mask_load(format_mask, SND_PCM_FMTBIT_LINEAR);
err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_FORMAT,
format_mask);
} else {
@ -259,8 +259,8 @@ static int snd_pcm_mulaw_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t
static int snd_pcm_mulaw_hw_refine_sprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *sparams)
{
snd_pcm_mulaw_t *mulaw = pcm->private;
mask_t *saccess_mask = alloca(mask_sizeof());
mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
snd_mask_t *saccess_mask = alloca(snd_mask_sizeof());
snd_mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
_snd_pcm_hw_params_any(sparams);
_snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
saccess_mask);

42
src/pcm/pcm_multi.c
View file

@ -102,10 +102,10 @@ static int snd_pcm_multi_info(snd_pcm_t *pcm, snd_pcm_info_t *info)
static int snd_pcm_multi_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
{
snd_pcm_multi_t *multi = pcm->private;
mask_t *access_mask = alloca(mask_sizeof());
snd_mask_t *access_mask = alloca(snd_mask_sizeof());
int err;
mask_any(access_mask);
mask_reset(access_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED);
snd_mask_any(access_mask);
snd_mask_reset(access_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED);
err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS,
access_mask);
if (err < 0)
@ -123,8 +123,8 @@ static int snd_pcm_multi_hw_refine_sprepare(snd_pcm_t *pcm, int slave_idx,
{
snd_pcm_multi_t *multi = pcm->private;
snd_pcm_multi_slave_t *slave = &multi->slaves[slave_idx];
mask_t *saccess_mask = alloca(mask_sizeof());
mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
snd_mask_t *saccess_mask = alloca(snd_mask_sizeof());
snd_mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
_snd_pcm_hw_params_any(sparams);
_snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
saccess_mask);
@ -148,13 +148,13 @@ static int snd_pcm_multi_hw_refine_schange(snd_pcm_t *pcm ATTRIBUTE_UNUSED,
SND_PCM_HW_PARBIT_BUFFER_SIZE |
SND_PCM_HW_PARBIT_BUFFER_TIME |
SND_PCM_HW_PARBIT_TICK_TIME);
const mask_t *access_mask = snd_pcm_hw_param_value_mask(params, SND_PCM_HW_PARAM_ACCESS);
if (!mask_test(access_mask, SND_PCM_ACCESS_RW_INTERLEAVED) &&
!mask_test(access_mask, SND_PCM_ACCESS_RW_NONINTERLEAVED) &&
!mask_test(access_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED)) {
mask_t *saccess_mask = alloca(mask_sizeof());
mask_any(saccess_mask);
mask_reset(saccess_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED);
const snd_mask_t *access_mask = snd_pcm_hw_param_value_mask(params, SND_PCM_HW_PARAM_ACCESS);
if (!snd_mask_test(access_mask, SND_PCM_ACCESS_RW_INTERLEAVED) &&
!snd_mask_test(access_mask, SND_PCM_ACCESS_RW_NONINTERLEAVED) &&
!snd_mask_test(access_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED)) {
snd_mask_t *saccess_mask = alloca(snd_mask_sizeof());
snd_mask_any(saccess_mask);
snd_mask_reset(saccess_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED);
err = _snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
saccess_mask);
if (err < 0)
@ -181,15 +181,15 @@ static int snd_pcm_multi_hw_refine_cchange(snd_pcm_t *pcm ATTRIBUTE_UNUSED,
SND_PCM_HW_PARBIT_BUFFER_SIZE |
SND_PCM_HW_PARBIT_BUFFER_TIME |
SND_PCM_HW_PARBIT_TICK_TIME);
mask_t *access_mask = alloca(mask_sizeof());
const mask_t *saccess_mask = snd_pcm_hw_param_value_mask(sparams, SND_PCM_HW_PARAM_ACCESS);
mask_any(access_mask);
mask_reset(access_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED);
if (!mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED))
mask_reset(access_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED);
if (!mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_COMPLEX) &&
!mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED))
mask_reset(access_mask, SND_PCM_ACCESS_MMAP_COMPLEX);
snd_mask_t *access_mask = alloca(snd_mask_sizeof());
const snd_mask_t *saccess_mask = snd_pcm_hw_param_value_mask(sparams, SND_PCM_HW_PARAM_ACCESS);
snd_mask_any(access_mask);
snd_mask_reset(access_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED);
if (!snd_mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED))
snd_mask_reset(access_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED);
if (!snd_mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_COMPLEX) &&
!snd_mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED))
snd_mask_reset(access_mask, SND_PCM_ACCESS_MMAP_COMPLEX);
err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS,
access_mask);
if (err < 0)

246
src/pcm/pcm_params.c
View file

@ -20,8 +20,8 @@
*/
#include "pcm_local.h"
#define INTERVAL_INLINE
#define MASK_INLINE
#define SND_INTERVAL_INLINE
#define SND_MASK_INLINE
#include "interval.h"
#include "mask.h"
@ -37,42 +37,42 @@ static inline int hw_is_interval(int var)
var <= SND_PCM_HW_PARAM_LAST_INTERVAL;
}
static inline mask_t *hw_param_mask(snd_pcm_hw_params_t *params,
static inline snd_mask_t *hw_param_mask(snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var)
{
assert(hw_is_mask(var));
return (mask_t*)&params->masks[var - SND_PCM_HW_PARAM_FIRST_MASK];
return (snd_mask_t*)&params->masks[var - SND_PCM_HW_PARAM_FIRST_MASK];
}
static inline interval_t *hw_param_interval(snd_pcm_hw_params_t *params,
static inline snd_interval_t *hw_param_interval(snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var)
{
assert(hw_is_interval(var));
return &params->intervals[var - SND_PCM_HW_PARAM_FIRST_INTERVAL];
}
static inline const mask_t *hw_param_mask_c(const snd_pcm_hw_params_t *params,
static inline const snd_mask_t *hw_param_mask_c(const snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var)
{
return (const mask_t *)hw_param_mask((snd_pcm_hw_params_t*) params, var);
return (const snd_mask_t *)hw_param_mask((snd_pcm_hw_params_t*) params, var);
}
static inline const interval_t *hw_param_interval_c(const snd_pcm_hw_params_t *params,
static inline const snd_interval_t *hw_param_interval_c(const snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var)
{
return (const interval_t *)hw_param_interval((snd_pcm_hw_params_t*) params, var);
return (const snd_interval_t *)hw_param_interval((snd_pcm_hw_params_t*) params, var);
}
void _snd_pcm_hw_param_any(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var)
{
if (hw_is_mask(var)) {
mask_any(hw_param_mask(params, var));
snd_mask_any(hw_param_mask(params, var));
params->cmask |= 1 << var;
params->rmask |= 1 << var;
return;
}
if (hw_is_interval(var)) {
interval_any(hw_param_interval(params, var));
snd_interval_any(hw_param_interval(params, var));
params->cmask |= 1 << var;
params->rmask |= 1 << var;
return;
@ -110,20 +110,20 @@ int snd_pcm_hw_param_value(const snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var, int *dir)
{
if (hw_is_mask(var)) {
const mask_t *mask = hw_param_mask_c(params, var);
if (!mask_single(mask))
const snd_mask_t *mask = hw_param_mask_c(params, var);
if (!snd_mask_single(mask))
return -EINVAL;
if (dir)
*dir = 0;
return mask_value(mask);
return snd_mask_value(mask);
}
if (hw_is_interval(var)) {
const interval_t *i = hw_param_interval_c(params, var);
if (!interval_single(i))
const snd_interval_t *i = hw_param_interval_c(params, var);
if (!snd_interval_single(i))
return -EINVAL;
if (dir)
*dir = i->openmin;
return interval_value(i);
return snd_interval_value(i);
}
assert(0);
return -EINVAL;
@ -136,13 +136,13 @@ unsigned int snd_pcm_hw_param_value_min(const snd_pcm_hw_params_t *params,
if (hw_is_mask(var)) {
if (dir)
*dir = 0;
return mask_min(hw_param_mask_c(params, var));
return snd_mask_min(hw_param_mask_c(params, var));
}
if (hw_is_interval(var)) {
const interval_t *i = hw_param_interval_c(params, var);
const snd_interval_t *i = hw_param_interval_c(params, var);
if (dir)
*dir = i->openmin;
return interval_min(i);
return snd_interval_min(i);
}
assert(0);
return -EINVAL;
@ -155,13 +155,13 @@ unsigned int snd_pcm_hw_param_value_max(const snd_pcm_hw_params_t *params,
if (hw_is_mask(var)) {
if (dir)
*dir = 0;
return mask_max(hw_param_mask_c(params, var));
return snd_mask_max(hw_param_mask_c(params, var));
}
if (hw_is_interval(var)) {
const interval_t *i = hw_param_interval_c(params, var);
const snd_interval_t *i = hw_param_interval_c(params, var);
if (dir)
*dir = - (int) i->openmax;
return interval_max(i);
return snd_interval_max(i);
}
assert(0);
return -EINVAL;
@ -170,7 +170,7 @@ unsigned int snd_pcm_hw_param_value_max(const snd_pcm_hw_params_t *params,
/* Return the mask for field PAR.
This function can be called only for SND_PCM_HW_PARAM_ACCESS,
SND_PCM_HW_PARAM_FORMAT, SND_PCM_HW_PARAM_SUBFORMAT. */
const mask_t *snd_pcm_hw_param_value_mask(const snd_pcm_hw_params_t *params,
const snd_mask_t *snd_pcm_hw_param_value_mask(const snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var)
{
assert(hw_is_mask(var));
@ -180,7 +180,7 @@ const mask_t *snd_pcm_hw_param_value_mask(const snd_pcm_hw_params_t *params,
/* Return the interval for field PAR.
This function cannot be called for SND_PCM_HW_PARAM_ACCESS,
SND_PCM_HW_PARAM_FORMAT, SND_PCM_HW_PARAM_SUBFORMAT. */
const interval_t *snd_pcm_hw_param_value_interval(const snd_pcm_hw_params_t *params,
const snd_interval_t *snd_pcm_hw_param_value_interval(const snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var)
{
assert(hw_is_interval(var));
@ -191,11 +191,11 @@ const interval_t *snd_pcm_hw_param_value_interval(const snd_pcm_hw_params_t *par
int _snd_pcm_hw_param_refine_interval(snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var,
const interval_t *val)
const snd_interval_t *val)
{
int changed;
assert(hw_is_interval(var));
changed = interval_refine(hw_param_interval(params, var), val);
changed = snd_interval_refine(hw_param_interval(params, var), val);
if (changed) {
params->cmask |= 1 << var;
params->rmask |= 1 << var;
@ -207,11 +207,11 @@ void _snd_pcm_hw_param_setempty(snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var)
{
if (hw_is_mask(var)) {
mask_none(hw_param_mask(params, var));
snd_mask_none(hw_param_mask(params, var));
params->cmask |= 1 << var;
params->rmask |= 1 << var;
} else if (hw_is_interval(var)) {
interval_none(hw_param_interval(params, var));
snd_interval_none(hw_param_interval(params, var));
params->cmask |= 1 << var;
params->rmask |= 1 << var;
} else {
@ -224,7 +224,7 @@ int _snd_pcm_hw_param_setinteger(snd_pcm_hw_params_t *params,
{
int changed;
assert(hw_is_interval(var));
changed = interval_setinteger(hw_param_interval(params, var));
changed = snd_interval_setinteger(hw_param_interval(params, var));
if (changed) {
params->cmask |= 1 << var;
params->rmask |= 1 << var;
@ -256,9 +256,9 @@ int _snd_pcm_hw_param_first(snd_pcm_hw_params_t *params,
{
int changed;
if (hw_is_mask(var))
changed = mask_refine_first(hw_param_mask(params, var));
changed = snd_mask_refine_first(hw_param_mask(params, var));
else if (hw_is_interval(var))
changed = interval_refine_first(hw_param_interval(params, var));
changed = snd_interval_refine_first(hw_param_interval(params, var));
else {
assert(0);
return -EINVAL;
@ -294,9 +294,9 @@ int _snd_pcm_hw_param_last(snd_pcm_hw_params_t *params,
{
int changed;
if (hw_is_mask(var))
changed = mask_refine_last(hw_param_mask(params, var));
changed = snd_mask_refine_last(hw_param_mask(params, var));
else if (hw_is_interval(var))
changed = interval_refine_last(hw_param_interval(params, var));
changed = snd_interval_refine_last(hw_param_interval(params, var));
else {
assert(0);
return -EINVAL;
@ -343,9 +343,9 @@ int _snd_pcm_hw_param_min(snd_pcm_hw_params_t *params,
}
}
if (hw_is_mask(var))
changed = mask_refine_min(hw_param_mask(params, var), val + !!open);
changed = snd_mask_refine_min(hw_param_mask(params, var), val + !!open);
else if (hw_is_interval(var))
changed = interval_refine_min(hw_param_interval(params, var), val, open);
changed = snd_interval_refine_min(hw_param_interval(params, var), val, open);
else {
assert(0);
return -EINVAL;
@ -403,12 +403,12 @@ int _snd_pcm_hw_param_max(snd_pcm_hw_params_t *params,
}
if (hw_is_mask(var)) {
if (val == 0 && open) {
mask_none(hw_param_mask(params, var));
snd_mask_none(hw_param_mask(params, var));
changed = -EINVAL;
} else
changed = mask_refine_max(hw_param_mask(params, var), val - !!open);
changed = snd_mask_refine_max(hw_param_mask(params, var), val - !!open);
} else if (hw_is_interval(var))
changed = interval_refine_max(hw_param_interval(params, var), val, open);
changed = snd_interval_refine_max(hw_param_interval(params, var), val, open);
else {
assert(0);
return -EINVAL;
@ -477,16 +477,16 @@ int _snd_pcm_hw_param_minmax(snd_pcm_hw_params_t *params,
}
}
if (hw_is_mask(var)) {
mask_t *mask = hw_param_mask(params, var);
snd_mask_t *mask = hw_param_mask(params, var);
if (max == 0 && openmax) {
mask_none(mask);
snd_mask_none(mask);
changed = -EINVAL;
} else {
c1 = mask_refine_min(mask, min + !!openmin);
c1 = snd_mask_refine_min(mask, min + !!openmin);
if (c1 < 0)
changed = c1;
else {
c2 = mask_refine_max(mask, max - !!openmax);
c2 = snd_mask_refine_max(mask, max - !!openmax);
if (c2 < 0)
changed = c2;
else
@ -495,12 +495,12 @@ int _snd_pcm_hw_param_minmax(snd_pcm_hw_params_t *params,
}
}
else if (hw_is_interval(var)) {
interval_t *i = hw_param_interval(params, var);
c1 = interval_refine_min(i, min, openmin);
snd_interval_t *i = hw_param_interval(params, var);
c1 = snd_interval_refine_min(i, min, openmin);
if (c1 < 0)
changed = c1;
else {
c2 = interval_refine_max(i, max, openmax);
c2 = snd_interval_refine_max(i, max, openmax);
if (c2 < 0)
changed = c2;
else
@ -562,26 +562,26 @@ int _snd_pcm_hw_param_set(snd_pcm_hw_params_t *params,
{
int changed;
if (hw_is_mask(var)) {
mask_t *m = hw_param_mask(params, var);
snd_mask_t *m = hw_param_mask(params, var);
if (val == 0 && dir < 0) {
changed = -EINVAL;
mask_none(m);
snd_mask_none(m);
} else {
if (dir > 0)
val++;
else if (dir < 0)
val--;
changed = mask_refine_set(hw_param_mask(params, var), val);
changed = snd_mask_refine_set(hw_param_mask(params, var), val);
}
} else if (hw_is_interval(var)) {
interval_t *i = hw_param_interval(params, var);
snd_interval_t *i = hw_param_interval(params, var);
if (val == 0 && dir < 0) {
changed = -EINVAL;
interval_none(i);
snd_interval_none(i);
} else if (dir == 0)
changed = interval_refine_set(i, val);
changed = snd_interval_refine_set(i, val);
else {
interval_t t;
snd_interval_t t;
t.openmin = 1;
t.openmax = 1;
t.empty = 0;
@ -593,7 +593,7 @@ int _snd_pcm_hw_param_set(snd_pcm_hw_params_t *params,
t.min = val;
t.max = val+1;
}
changed = interval_refine(i, &t);
changed = snd_interval_refine(i, &t);
}
} else {
assert(0);
@ -637,11 +637,11 @@ int snd_pcm_hw_param_set_try(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
}
int _snd_pcm_hw_param_mask(snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var, const mask_t *val)
snd_pcm_hw_param_t var, const snd_mask_t *val)
{
int changed;
assert(hw_is_mask(var));
changed = mask_refine(hw_param_mask(params, var), val);
changed = snd_mask_refine(hw_param_mask(params, var), val);
if (changed) {
params->cmask |= 1 << var;
params->rmask |= 1 << var;
@ -657,7 +657,7 @@ int _snd_pcm_hw_param_mask(snd_pcm_hw_params_t *params,
if the configuration space is empty
*/
int snd_pcm_hw_param_mask(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var, const mask_t *val)
snd_pcm_hw_param_t var, const snd_mask_t *val)
{
int changed = _snd_pcm_hw_param_mask(params, var, val);
if (changed < 0)
@ -670,8 +670,8 @@ int snd_pcm_hw_param_mask(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
return 0;
}
int snd_pcm_hw_param_mask_try(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var, const mask_t *val)
int snd_pcm_hw_param_snd_mask_try(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var, const snd_mask_t *val)
{
snd_pcm_hw_params_t save;
int err;
@ -859,9 +859,9 @@ int snd_pcm_hw_param_empty(const snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var)
{
if (hw_is_mask(var))
return mask_empty(hw_param_mask_c(params, var));
return snd_mask_empty(hw_param_mask_c(params, var));
if (hw_is_interval(var))
return interval_empty(hw_param_interval_c(params, var));
return snd_interval_empty(hw_param_interval_c(params, var));
assert(0);
return -EINVAL;
}
@ -871,10 +871,10 @@ int snd_pcm_hw_param_always_eq(const snd_pcm_hw_params_t *params,
const snd_pcm_hw_params_t *params1)
{
if (hw_is_mask(var))
return mask_always_eq(hw_param_mask_c(params, var),
return snd_mask_always_eq(hw_param_mask_c(params, var),
hw_param_mask_c(params1, var));
if (hw_is_interval(var))
return interval_always_eq(hw_param_interval_c(params, var),
return snd_interval_always_eq(hw_param_interval_c(params, var),
hw_param_interval_c(params1, var));
assert(0);
return -EINVAL;
@ -885,10 +885,10 @@ int snd_pcm_hw_param_never_eq(const snd_pcm_hw_params_t *params,
const snd_pcm_hw_params_t *params1)
{
if (hw_is_mask(var))
return mask_never_eq(hw_param_mask_c(params, var),
return snd_mask_never_eq(hw_param_mask_c(params, var),
hw_param_mask_c(params1, var));
if (hw_is_interval(var))
return interval_never_eq(hw_param_interval_c(params, var),
return snd_interval_never_eq(hw_param_interval_c(params, var),
hw_param_interval_c(params1, var));
assert(0);
return -EINVAL;
@ -1026,12 +1026,12 @@ int snd_pcm_hw_param_test(const snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var, unsigned int val)
{
if (hw_is_mask(var)) {
const mask_t *mask = hw_param_mask_c(params, var);
return mask_test(mask, val);
const snd_mask_t *mask = hw_param_mask_c(params, var);
return snd_mask_test(mask, val);
}
if (hw_is_interval(var)) {
const interval_t *i = hw_param_interval_c(params, var);
return interval_test(i, val);
const snd_interval_t *i = hw_param_interval_c(params, var);
return snd_interval_test(i, val);
}
assert(0);
return -EINVAL;
@ -1041,12 +1041,12 @@ unsigned int snd_pcm_hw_param_count(const snd_pcm_hw_params_t *params,
snd_pcm_hw_param_t var)
{
if (hw_is_mask(var)) {
const mask_t *mask = hw_param_mask_c(params, var);
return mask_count(mask);
const snd_mask_t *mask = hw_param_mask_c(params, var);
return snd_mask_count(mask);
}
if (hw_is_interval(var)) {
const interval_t *i = hw_param_interval_c(params, var);
return interval_max(i) - interval_min(i) + 1;
const snd_interval_t *i = hw_param_interval_c(params, var);
return snd_interval_max(i) - snd_interval_min(i) + 1;
}
assert(0);
return 0;
@ -1058,13 +1058,13 @@ int _snd_pcm_hw_param_refine(snd_pcm_hw_params_t *params,
{
int changed = 0;
if (hw_is_mask(var)) {
mask_t *d = hw_param_mask(params, var);
const mask_t *s = hw_param_mask_c(src, var);
changed = mask_refine(d, s);
snd_mask_t *d = hw_param_mask(params, var);
const snd_mask_t *s = hw_param_mask_c(src, var);
changed = snd_mask_refine(d, s);
} else if (hw_is_interval(var)) {
interval_t *d = hw_param_interval(params, var);
const interval_t *s = hw_param_interval_c(src, var);
changed = interval_refine(d, s);
snd_interval_t *d = hw_param_interval(params, var);
const snd_interval_t *s = hw_param_interval_c(src, var);
changed = snd_interval_refine(d, s);
} else
assert(0);
if (changed) {
@ -1078,16 +1078,16 @@ void _snd_pcm_hw_param_copy(snd_pcm_hw_params_t *params, snd_pcm_hw_param_t var,
const snd_pcm_hw_params_t *src)
{
if (hw_is_mask(var)) {
mask_t *d = hw_param_mask(params, var);
const mask_t *s = hw_param_mask_c(src, var);
mask_copy(d, s);
snd_mask_t *d = hw_param_mask(params, var);
const snd_mask_t *s = hw_param_mask_c(src, var);
snd_mask_copy(d, s);
params->cmask |= 1 << var;
params->rmask |= 1 << var;
}
if (hw_is_interval(var)) {
interval_t *d = hw_param_interval(params, var);
const interval_t *s = hw_param_interval_c(src, var);
interval_copy(d, s);
snd_interval_t *d = hw_param_interval(params, var);
const snd_interval_t *s = hw_param_interval_c(src, var);
snd_interval_copy(d, s);
params->cmask |= 1 << var;
params->rmask |= 1 << var;
}
@ -1103,10 +1103,10 @@ void snd_pcm_hw_param_dump(const snd_pcm_hw_params_t *params,
[SND_PCM_HW_PARAM_SUBFORMAT] = snd_pcm_subformat_name,
};
if (hw_is_mask(var)) {
const mask_t *mask = hw_param_mask_c(params, var);
if (mask_empty(mask))
const snd_mask_t *mask = hw_param_mask_c(params, var);
if (snd_mask_empty(mask))
snd_output_puts(out, " NONE");
else if (mask_full(mask))
else if (snd_mask_full(mask))
snd_output_puts(out, " ALL");
else {
unsigned int k;
@ -1114,8 +1114,8 @@ void snd_pcm_hw_param_dump(const snd_pcm_hw_params_t *params,
assert(var < sizeof(funcs) / sizeof(funcs[0]));
f = funcs[var];
assert(f);
for (k = 0; k <= MASK_MAX; ++k) {
if (mask_test(mask, k)) {
for (k = 0; k <= SND_MASK_MAX; ++k) {
if (snd_mask_test(mask, k)) {
const char *s = f(k);
if (s) {
snd_output_putc(out, ' ');
@ -1127,7 +1127,7 @@ void snd_pcm_hw_param_dump(const snd_pcm_hw_params_t *params,
return;
}
if (hw_is_interval(var)) {
interval_print(hw_param_interval_c(params, var), out);
snd_interval_print(hw_param_interval_c(params, var), out);
return;
}
assert(0);
@ -1513,39 +1513,39 @@ struct _snd_pcm_hw_rule {
int snd_pcm_hw_rule_mul(snd_pcm_hw_params_t *params,
snd_pcm_hw_rule_t *rule)
{
interval_t t;
interval_mul(hw_param_interval_c(params, rule->deps[0]),
snd_interval_t t;
snd_interval_mul(hw_param_interval_c(params, rule->deps[0]),
hw_param_interval_c(params, rule->deps[1]), &t);
return interval_refine(hw_param_interval(params, rule->var), &t);
return snd_interval_refine(hw_param_interval(params, rule->var), &t);
}
int snd_pcm_hw_rule_div(snd_pcm_hw_params_t *params,
snd_pcm_hw_rule_t *rule)
{
interval_t t;
interval_div(hw_param_interval_c(params, rule->deps[0]),
snd_interval_t t;
snd_interval_div(hw_param_interval_c(params, rule->deps[0]),
hw_param_interval_c(params, rule->deps[1]), &t);
return interval_refine(hw_param_interval(params, rule->var), &t);
return snd_interval_refine(hw_param_interval(params, rule->var), &t);
}
int snd_pcm_hw_rule_muldivk(snd_pcm_hw_params_t *params,
snd_pcm_hw_rule_t *rule)
{
interval_t t;
interval_muldivk(hw_param_interval_c(params, rule->deps[0]),
snd_interval_t t;
snd_interval_muldivk(hw_param_interval_c(params, rule->deps[0]),
hw_param_interval_c(params, rule->deps[1]),
(unsigned long) rule->private, &t);
return interval_refine(hw_param_interval(params, rule->var), &t);
return snd_interval_refine(hw_param_interval(params, rule->var), &t);
}
int snd_pcm_hw_rule_mulkdiv(snd_pcm_hw_params_t *params,
snd_pcm_hw_rule_t *rule)
{
interval_t t;
interval_mulkdiv(hw_param_interval_c(params, rule->deps[0]),
snd_interval_t t;
snd_interval_mulkdiv(hw_param_interval_c(params, rule->deps[0]),
(unsigned long) rule->private,
hw_param_interval_c(params, rule->deps[1]), &t);
return interval_refine(hw_param_interval(params, rule->var), &t);
return snd_interval_refine(hw_param_interval(params, rule->var), &t);
}
int snd_pcm_hw_rule_format(snd_pcm_hw_params_t *params,
@ -1553,18 +1553,18 @@ int snd_pcm_hw_rule_format(snd_pcm_hw_params_t *params,
{
int changed = 0;
unsigned int k;
mask_t *mask = hw_param_mask(params, rule->var);
interval_t *i = hw_param_interval(params, rule->deps[0]);
snd_mask_t *mask = hw_param_mask(params, rule->var);
snd_interval_t *i = hw_param_interval(params, rule->deps[0]);
for (k = 0; k <= SND_PCM_FORMAT_LAST; ++k) {
int bits;
if (!mask_test(mask, k))
if (!snd_mask_test(mask, k))
continue;
bits = snd_pcm_format_physical_width(k);
if (bits < 0)
continue;
if (!interval_test(i, bits)) {
mask_reset(mask, k);
if (mask_empty(mask))
if (!snd_interval_test(i, bits)) {
snd_mask_reset(mask, k);
if (snd_mask_empty(mask))
return -EINVAL;
changed = 1;
}
@ -1578,14 +1578,14 @@ int snd_pcm_hw_rule_sample_bits(snd_pcm_hw_params_t *params,
{
unsigned int min, max;
unsigned int k;
interval_t *i = hw_param_interval(params, rule->var);
mask_t *mask = hw_param_mask(params, rule->deps[0]);
snd_interval_t *i = hw_param_interval(params, rule->var);
snd_mask_t *mask = hw_param_mask(params, rule->deps[0]);
int c, changed = 0;
min = UINT_MAX;
max = 0;
for (k = 0; k <= SND_PCM_FORMAT_LAST; ++k) {
int bits;
if (!mask_test(mask, k))
if (!snd_mask_test(mask, k))
continue;
bits = snd_pcm_format_physical_width(k);
if (bits < 0)
@ -1595,12 +1595,12 @@ int snd_pcm_hw_rule_sample_bits(snd_pcm_hw_params_t *params,
if (max < (unsigned)bits)
max = bits;
}
c = interval_refine_min(i, min, 0);
c = snd_interval_refine_min(i, min, 0);
if (c < 0)
return c;
if (c)
changed = 1;
c = interval_refine_max(i, max, 0);
c = snd_interval_refine_max(i, max, 0);
if (c < 0)
return c;
if (c)
@ -1752,7 +1752,7 @@ static snd_pcm_hw_rule_t refine_rules[] = {
#define RULES (sizeof(refine_rules) / sizeof(refine_rules[0]))
static mask_t refine_masks[SND_PCM_HW_PARAM_LAST_MASK - SND_PCM_HW_PARAM_FIRST_MASK + 1] = {
static snd_mask_t refine_masks[SND_PCM_HW_PARAM_LAST_MASK - SND_PCM_HW_PARAM_FIRST_MASK + 1] = {
[SND_PCM_HW_PARAM_ACCESS - SND_PCM_HW_PARAM_FIRST_MASK] = {
bits: (1 << (SND_PCM_ACCESS_LAST + 1)) - 1,
},
@ -1764,7 +1764,7 @@ static mask_t refine_masks[SND_PCM_HW_PARAM_LAST_MASK - SND_PCM_HW_PARAM_FIRST_M
},
};
static interval_t refine_intervals[SND_PCM_HW_PARAM_LAST_INTERVAL - SND_PCM_HW_PARAM_FIRST_INTERVAL + 1] = {
static snd_interval_t refine_intervals[SND_PCM_HW_PARAM_LAST_INTERVAL - SND_PCM_HW_PARAM_FIRST_INTERVAL + 1] = {
[SND_PCM_HW_PARAM_SAMPLE_BITS - SND_PCM_HW_PARAM_FIRST_INTERVAL] = {
min: 1, max: UINT_MAX,
openmin: 0, openmax: 0, integer: 1, empty: 0,
@ -1820,7 +1820,7 @@ static interval_t refine_intervals[SND_PCM_HW_PARAM_LAST_INTERVAL - SND_PCM_HW_P
int snd_pcm_hw_refine_soft(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *params)
{
unsigned int k;
interval_t *i;
snd_interval_t *i;
unsigned int rstamps[RULES];
unsigned int vstamps[SND_PCM_HW_PARAM_LAST + 1];
unsigned int stamp = 2;
@ -1833,7 +1833,7 @@ int snd_pcm_hw_refine_soft(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t
for (k = SND_PCM_HW_PARAM_FIRST_MASK; k <= SND_PCM_HW_PARAM_LAST_MASK; k++) {
if (!(params->rmask & (1 << k)))
continue;
changed = mask_refine(hw_param_mask(params, k),
changed = snd_mask_refine(hw_param_mask(params, k),
&refine_masks[k - SND_PCM_HW_PARAM_FIRST_MASK]);
if (changed)
params->cmask |= 1 << k;
@ -1844,7 +1844,7 @@ int snd_pcm_hw_refine_soft(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t
for (k = SND_PCM_HW_PARAM_FIRST_INTERVAL; k <= SND_PCM_HW_PARAM_LAST_INTERVAL; k++) {
if (!(params->rmask & (1 << k)))
continue;
changed = interval_refine(hw_param_interval(params, k),
changed = snd_interval_refine(hw_param_interval(params, k),
&refine_intervals[k - SND_PCM_HW_PARAM_FIRST_INTERVAL]);
if (changed)
params->cmask |= 1 << k;
@ -1902,14 +1902,14 @@ int snd_pcm_hw_refine_soft(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t
} while (again);
if (!params->msbits) {
i = hw_param_interval(params, SND_PCM_HW_PARAM_SAMPLE_BITS);
if (interval_single(i))
params->msbits = interval_value(i);
if (snd_interval_single(i))
params->msbits = snd_interval_value(i);
}
if (!params->rate_den) {
i = hw_param_interval(params, SND_PCM_HW_PARAM_RATE);
if (interval_single(i)) {
params->rate_num = interval_value(i);
if (snd_interval_single(i)) {
params->rate_num = snd_interval_value(i);
params->rate_den = 1;
}
}

68
src/pcm/pcm_plug.c
View file

@ -120,14 +120,14 @@ static unsigned int nonlinear_preferred_formats[] = {
SND_PCM_FORMAT_IMA_ADPCM,
};
static int snd_pcm_plug_slave_format(int format, const mask_t *format_mask)
static int snd_pcm_plug_slave_format(int format, const snd_mask_t *format_mask)
{
int w, u, e, wid, w1, dw;
mask_t *lin = alloca(mask_sizeof());
if (mask_test(format_mask, format))
snd_mask_t *lin = alloca(snd_mask_sizeof());
if (snd_mask_test(format_mask, format))
return format;
mask_load(lin, SND_PCM_FMTBIT_LINEAR);
if (!mask_test(lin, format)) {
snd_mask_load(lin, SND_PCM_FMTBIT_LINEAR);
if (!snd_mask_test(lin, format)) {
unsigned int i;
switch (format) {
case SND_PCM_FORMAT_MU_LAW:
@ -135,7 +135,7 @@ static int snd_pcm_plug_slave_format(int format, const mask_t *format_mask)
case SND_PCM_FORMAT_IMA_ADPCM:
for (i = 0; i < sizeof(linear_preferred_formats) / sizeof(linear_preferred_formats[0]); ++i) {
unsigned int f = linear_preferred_formats[i];
if (mask_test(format_mask, f))
if (snd_mask_test(format_mask, f))
return f;
}
/* Fall through */
@ -144,12 +144,12 @@ static int snd_pcm_plug_slave_format(int format, const mask_t *format_mask)
}
}
mask_intersect(lin, format_mask);
if (mask_empty(lin)) {
snd_mask_intersect(lin, format_mask);
if (snd_mask_empty(lin)) {
unsigned int i;
for (i = 0; i < sizeof(nonlinear_preferred_formats) / sizeof(nonlinear_preferred_formats[0]); ++i) {
unsigned int f = nonlinear_preferred_formats[i];
if (mask_test(format_mask, f))
if (snd_mask_test(format_mask, f))
return f;
}
return -EINVAL;
@ -166,7 +166,7 @@ static int snd_pcm_plug_slave_format(int format, const mask_t *format_mask)
for (sgn = 0; sgn < 2; ++sgn) {
int f;
f = snd_pcm_build_linear_format(w1, u1, e1);
if (f >= 0 && mask_test(format_mask, f))
if (f >= 0 && snd_mask_test(format_mask, f))
return f;
u1 = !u1;
}
@ -419,12 +419,12 @@ static int snd_pcm_plug_hw_refine_schange(snd_pcm_t *pcm, snd_pcm_hw_params_t *p
snd_pcm_t *slave = plug->req_slave;
unsigned int links = (SND_PCM_HW_PARBIT_PERIOD_TIME |
SND_PCM_HW_PARBIT_TICK_TIME);
const mask_t *format_mask, *sformat_mask;
mask_t *sfmt_mask = alloca(mask_sizeof());
const snd_mask_t *format_mask, *sformat_mask;
snd_mask_t *sfmt_mask = alloca(snd_mask_sizeof());
int err;
unsigned int format;
interval_t t, buffer_size;
const interval_t *srate, *crate;
snd_interval_t t, buffer_size;
const snd_interval_t *srate, *crate;
snd_pcm_hw_param_refine_near(slave, sparams, SND_PCM_HW_PARAM_RATE,
params);
snd_pcm_hw_param_refine_near(slave, sparams, SND_PCM_HW_PARAM_CHANNELS,
@ -433,19 +433,19 @@ static int snd_pcm_plug_hw_refine_schange(snd_pcm_t *pcm, snd_pcm_hw_params_t *p
SND_PCM_HW_PARAM_FORMAT);
sformat_mask = snd_pcm_hw_param_value_mask(sparams,
SND_PCM_HW_PARAM_FORMAT);
mask_none(sfmt_mask);
snd_mask_none(sfmt_mask);
for (format = 0; format <= SND_PCM_FORMAT_LAST; format++) {
int f;
if (!mask_test(format_mask, format))
if (!snd_mask_test(format_mask, format))
continue;
if (mask_test(sformat_mask, format))
if (snd_mask_test(sformat_mask, format))
f = format;
else {
f = snd_pcm_plug_slave_format(format, sformat_mask);
if (f < 0)
continue;
}
mask_set(sfmt_mask, f);
snd_mask_set(sfmt_mask, f);
}
err = snd_pcm_hw_param_mask(slave, sparams,
@ -456,16 +456,16 @@ static int snd_pcm_plug_hw_refine_schange(snd_pcm_t *pcm, snd_pcm_hw_params_t *p
snd_pcm_hw_param_never_eq(params, SND_PCM_HW_PARAM_CHANNELS, sparams) ||
snd_pcm_hw_param_never_eq(params, SND_PCM_HW_PARAM_RATE, sparams) ||
snd_pcm_hw_param_never_eq(params, SND_PCM_HW_PARAM_ACCESS, sparams)) {
mask_t *access_mask = alloca(mask_sizeof());
mask_load(access_mask, SND_PCM_ACCBIT_MMAP);
snd_mask_t *access_mask = alloca(snd_mask_sizeof());
snd_mask_load(access_mask, SND_PCM_ACCBIT_MMAP);
_snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
access_mask);
}
interval_copy(&buffer_size, snd_pcm_hw_param_value_interval(params, SND_PCM_HW_PARAM_BUFFER_SIZE));
interval_unfloor(&buffer_size);
snd_interval_copy(&buffer_size, snd_pcm_hw_param_value_interval(params, SND_PCM_HW_PARAM_BUFFER_SIZE));
snd_interval_unfloor(&buffer_size);
crate = snd_pcm_hw_param_value_interval(params, SND_PCM_HW_PARAM_RATE);
srate = snd_pcm_hw_param_value_interval(sparams, SND_PCM_HW_PARAM_RATE);
interval_muldiv(&buffer_size, srate, crate, &t);
snd_interval_muldiv(&buffer_size, srate, crate, &t);
err = _snd_pcm_hw_param_refine_interval(sparams, SND_PCM_HW_PARAM_BUFFER_SIZE, &t);
if (err < 0)
return err;
@ -481,32 +481,32 @@ static int snd_pcm_plug_hw_refine_cchange(snd_pcm_t *pcm ATTRIBUTE_UNUSED,
{
unsigned int links = (SND_PCM_HW_PARBIT_PERIOD_TIME |
SND_PCM_HW_PARBIT_TICK_TIME);
const mask_t *format_mask, *sformat_mask;
mask_t *fmt_mask = alloca(mask_sizeof());
const snd_mask_t *format_mask, *sformat_mask;
snd_mask_t *fmt_mask = alloca(snd_mask_sizeof());
int err;
unsigned int format;
interval_t t;
const interval_t *sbuffer_size;
const interval_t *srate, *crate;
snd_interval_t t;
const snd_interval_t *sbuffer_size;
const snd_interval_t *srate, *crate;
unsigned int rate_min, srate_min;
int rate_mindir, srate_mindir;
format_mask = snd_pcm_hw_param_value_mask(params,
SND_PCM_HW_PARAM_FORMAT);
sformat_mask = snd_pcm_hw_param_value_mask(sparams,
SND_PCM_HW_PARAM_FORMAT);
mask_none(fmt_mask);
snd_mask_none(fmt_mask);
for (format = 0; format <= SND_PCM_FORMAT_LAST; format++) {
int f;
if (!mask_test(format_mask, format))
if (!snd_mask_test(format_mask, format))
continue;
if (mask_test(sformat_mask, format))
if (snd_mask_test(sformat_mask, format))
f = format;
else {
f = snd_pcm_plug_slave_format(format, sformat_mask);
if (f < 0)
continue;
}
mask_set(fmt_mask, format);
snd_mask_set(fmt_mask, format);
}
err = _snd_pcm_hw_param_mask(params,
@ -526,8 +526,8 @@ static int snd_pcm_plug_hw_refine_cchange(snd_pcm_t *pcm ATTRIBUTE_UNUSED,
sbuffer_size = snd_pcm_hw_param_value_interval(sparams, SND_PCM_HW_PARAM_BUFFER_SIZE);
crate = snd_pcm_hw_param_value_interval(params, SND_PCM_HW_PARAM_RATE);
srate = snd_pcm_hw_param_value_interval(sparams, SND_PCM_HW_PARAM_RATE);
interval_muldiv(sbuffer_size, crate, srate, &t);
interval_floor(&t);
snd_interval_muldiv(sbuffer_size, crate, srate, &t);
snd_interval_floor(&t);
err = _snd_pcm_hw_param_refine_interval(params, SND_PCM_HW_PARAM_BUFFER_SIZE, &t);
if (err < 0)
return err;

32
src/pcm/pcm_rate.c
View file

@ -225,10 +225,10 @@ snd_pcm_uframes_t snd_pcm_rate_shrink(const snd_pcm_channel_area_t *src_areas,
static int snd_pcm_rate_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *params)
{
int err;
mask_t *access_mask = alloca(mask_sizeof());
mask_t *format_mask = alloca(mask_sizeof());
mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN);
mask_load(format_mask, SND_PCM_FMTBIT_LINEAR);
snd_mask_t *access_mask = alloca(snd_mask_sizeof());
snd_mask_t *format_mask = alloca(snd_mask_sizeof());
snd_mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN);
snd_mask_load(format_mask, SND_PCM_FMTBIT_LINEAR);
err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS,
access_mask);
if (err < 0)
@ -256,8 +256,8 @@ static int snd_pcm_rate_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_
static int snd_pcm_rate_hw_refine_sprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *sparams)
{
snd_pcm_rate_t *rate = pcm->private;
mask_t *saccess_mask = alloca(mask_sizeof());
mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
snd_mask_t *saccess_mask = alloca(snd_mask_sizeof());
snd_mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
_snd_pcm_hw_params_any(sparams);
_snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
saccess_mask);
@ -276,8 +276,8 @@ static int snd_pcm_rate_hw_refine_schange(snd_pcm_t *pcm, snd_pcm_hw_params_t *p
snd_pcm_hw_params_t *sparams)
{
snd_pcm_rate_t *rate = pcm->private;
interval_t t, buffer_size;
const interval_t *srate, *crate;
snd_interval_t t, buffer_size;
const snd_interval_t *srate, *crate;
int err;
unsigned int links = (SND_PCM_HW_PARBIT_CHANNELS |
SND_PCM_HW_PARBIT_PERIOD_TIME |
@ -287,11 +287,11 @@ static int snd_pcm_rate_hw_refine_schange(snd_pcm_t *pcm, snd_pcm_hw_params_t *p
SND_PCM_HW_PARBIT_SUBFORMAT |
SND_PCM_HW_PARBIT_SAMPLE_BITS |
SND_PCM_HW_PARBIT_FRAME_BITS);
interval_copy(&buffer_size, snd_pcm_hw_param_value_interval(params, SND_PCM_HW_PARAM_BUFFER_SIZE));
interval_unfloor(&buffer_size);
snd_interval_copy(&buffer_size, snd_pcm_hw_param_value_interval(params, SND_PCM_HW_PARAM_BUFFER_SIZE));
snd_interval_unfloor(&buffer_size);
crate = snd_pcm_hw_param_value_interval(params, SND_PCM_HW_PARAM_RATE);
srate = snd_pcm_hw_param_value_interval(sparams, SND_PCM_HW_PARAM_RATE);
interval_muldiv(&buffer_size, srate, crate, &t);
snd_interval_muldiv(&buffer_size, srate, crate, &t);
err = _snd_pcm_hw_param_refine_interval(sparams, SND_PCM_HW_PARAM_BUFFER_SIZE, &t);
if (err < 0)
return err;
@ -305,9 +305,9 @@ static int snd_pcm_rate_hw_refine_cchange(snd_pcm_t *pcm, snd_pcm_hw_params_t *p
snd_pcm_hw_params_t *sparams)
{
snd_pcm_rate_t *rate = pcm->private;
interval_t t;
const interval_t *sbuffer_size;
const interval_t *srate, *crate;
snd_interval_t t;
const snd_interval_t *sbuffer_size;
const snd_interval_t *srate, *crate;
int err;
unsigned int links = (SND_PCM_HW_PARBIT_CHANNELS |
SND_PCM_HW_PARBIT_PERIOD_TIME |
@ -320,8 +320,8 @@ static int snd_pcm_rate_hw_refine_cchange(snd_pcm_t *pcm, snd_pcm_hw_params_t *p
sbuffer_size = snd_pcm_hw_param_value_interval(sparams, SND_PCM_HW_PARAM_BUFFER_SIZE);
crate = snd_pcm_hw_param_value_interval(params, SND_PCM_HW_PARAM_RATE);
srate = snd_pcm_hw_param_value_interval(sparams, SND_PCM_HW_PARAM_RATE);
interval_muldiv(sbuffer_size, crate, srate, &t);
interval_floor(&t);
snd_interval_muldiv(sbuffer_size, crate, srate, &t);
snd_interval_floor(&t);
err = _snd_pcm_hw_param_refine_interval(params, SND_PCM_HW_PARAM_BUFFER_SIZE, &t);
if (err < 0)
return err;

12
src/pcm/pcm_route.c
View file

@ -428,10 +428,10 @@ static int snd_pcm_route_close(snd_pcm_t *pcm)
static int snd_pcm_route_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *params)
{
int err;
mask_t *access_mask = alloca(mask_sizeof());
mask_t *format_mask = alloca(mask_sizeof());
mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN);
mask_load(format_mask, SND_PCM_FMTBIT_LINEAR);
snd_mask_t *access_mask = alloca(snd_mask_sizeof());
snd_mask_t *format_mask = alloca(snd_mask_sizeof());
snd_mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN);
snd_mask_load(format_mask, SND_PCM_FMTBIT_LINEAR);
err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS,
access_mask);
if (err < 0)
@ -454,8 +454,8 @@ static int snd_pcm_route_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd
static int snd_pcm_route_hw_refine_sprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *sparams)
{
snd_pcm_route_t *route = pcm->private;
mask_t *saccess_mask = alloca(mask_sizeof());
mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
snd_mask_t *saccess_mask = alloca(snd_mask_sizeof());
snd_mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
_snd_pcm_hw_params_any(sparams);
_snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
saccess_mask);

42
src/pcm/pcm_share.c
View file

@ -460,10 +460,10 @@ static int snd_pcm_share_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t
{
snd_pcm_share_t *share = pcm->private;
snd_pcm_share_slave_t *slave = share->slave;
mask_t *access_mask = alloca(mask_sizeof());
snd_mask_t *access_mask = alloca(snd_mask_sizeof());
int err;
mask_any(access_mask);
mask_reset(access_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED);
snd_mask_any(access_mask);
snd_mask_reset(access_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED);
err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS,
access_mask);
if (err < 0)
@ -493,8 +493,8 @@ static int snd_pcm_share_hw_refine_sprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t
{
snd_pcm_share_t *share = pcm->private;
snd_pcm_share_slave_t *slave = share->slave;
mask_t *saccess_mask = alloca(mask_sizeof());
mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
snd_mask_t *saccess_mask = alloca(snd_mask_sizeof());
snd_mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
_snd_pcm_hw_params_any(sparams);
_snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
saccess_mask);
@ -516,13 +516,13 @@ static int snd_pcm_share_hw_refine_schange(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_
SND_PCM_HW_PARBIT_BUFFER_TIME |
SND_PCM_HW_PARBIT_PERIODS |
SND_PCM_HW_PARBIT_TICK_TIME);
const mask_t *access_mask = snd_pcm_hw_param_value_mask(params, SND_PCM_HW_PARAM_ACCESS);
if (!mask_test(access_mask, SND_PCM_ACCESS_RW_INTERLEAVED) &&
!mask_test(access_mask, SND_PCM_ACCESS_RW_NONINTERLEAVED) &&
!mask_test(access_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED)) {
mask_t *saccess_mask = alloca(mask_sizeof());
mask_any(saccess_mask);
mask_reset(saccess_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED);
const snd_mask_t *access_mask = snd_pcm_hw_param_value_mask(params, SND_PCM_HW_PARAM_ACCESS);
if (!snd_mask_test(access_mask, SND_PCM_ACCESS_RW_INTERLEAVED) &&
!snd_mask_test(access_mask, SND_PCM_ACCESS_RW_NONINTERLEAVED) &&
!snd_mask_test(access_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED)) {
snd_mask_t *saccess_mask = alloca(snd_mask_sizeof());
snd_mask_any(saccess_mask);
snd_mask_reset(saccess_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED);
err = _snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
saccess_mask);
if (err < 0)
@ -547,15 +547,15 @@ static int snd_pcm_share_hw_refine_cchange(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_
SND_PCM_HW_PARBIT_BUFFER_TIME |
SND_PCM_HW_PARBIT_PERIODS |
SND_PCM_HW_PARBIT_TICK_TIME);
mask_t *access_mask = alloca(mask_sizeof());
const mask_t *saccess_mask = snd_pcm_hw_param_value_mask(sparams, SND_PCM_HW_PARAM_ACCESS);
mask_any(access_mask);
mask_reset(access_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED);
if (!mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED))
mask_reset(access_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED);
if (!mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_COMPLEX) &&
!mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED))
mask_reset(access_mask, SND_PCM_ACCESS_MMAP_COMPLEX);
snd_mask_t *access_mask = alloca(snd_mask_sizeof());
const snd_mask_t *saccess_mask = snd_pcm_hw_param_value_mask(sparams, SND_PCM_HW_PARAM_ACCESS);
snd_mask_any(access_mask);
snd_mask_reset(access_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED);
if (!snd_mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED))
snd_mask_reset(access_mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED);
if (!snd_mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_COMPLEX) &&
!snd_mask_test(saccess_mask, SND_PCM_ACCESS_MMAP_INTERLEAVED))
snd_mask_reset(access_mask, SND_PCM_ACCESS_MMAP_COMPLEX);
err = _snd_pcm_hw_param_mask(params, SND_PCM_HW_PARAM_ACCESS,
access_mask);
if (err < 0)

18
src/pcm/pcm_shm.c
View file

@ -162,8 +162,8 @@ static int snd_pcm_shm_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_p
static int snd_pcm_shm_hw_refine_sprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *sparams)
{
mask_t *saccess_mask = alloca(mask_sizeof());
mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
snd_mask_t *saccess_mask = alloca(snd_mask_sizeof());
snd_mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
_snd_pcm_hw_params_any(sparams);
_snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
saccess_mask);
@ -175,9 +175,9 @@ static int snd_pcm_shm_hw_refine_schange(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pc
{
int err;
unsigned int links = ~SND_PCM_HW_PARBIT_ACCESS;
const mask_t *access_mask = snd_pcm_hw_param_value_mask(params, SND_PCM_HW_PARAM_ACCESS);
if (!mask_test(access_mask, SND_PCM_ACCESS_RW_INTERLEAVED) &&
!mask_test(access_mask, SND_PCM_ACCESS_RW_NONINTERLEAVED)) {
const snd_mask_t *access_mask = snd_pcm_hw_param_value_mask(params, SND_PCM_HW_PARAM_ACCESS);
if (!snd_mask_test(access_mask, SND_PCM_ACCESS_RW_INTERLEAVED) &&
!snd_mask_test(access_mask, SND_PCM_ACCESS_RW_NONINTERLEAVED)) {
err = _snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
access_mask);
if (err < 0)
@ -194,10 +194,10 @@ static int snd_pcm_shm_hw_refine_cchange(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pc
{
int err;
unsigned int links = ~SND_PCM_HW_PARBIT_ACCESS;
mask_t *access_mask = alloca(mask_sizeof());
mask_copy(access_mask, snd_pcm_hw_param_value_mask(sparams, SND_PCM_HW_PARAM_ACCESS));
mask_set(access_mask, SND_PCM_ACCESS_RW_INTERLEAVED);
mask_set(access_mask, SND_PCM_ACCESS_RW_NONINTERLEAVED);
snd_mask_t *access_mask = alloca(snd_mask_sizeof());
snd_mask_copy(access_mask, snd_pcm_hw_param_value_mask(sparams, SND_PCM_HW_PARAM_ACCESS));
snd_mask_set(access_mask, SND_PCM_ACCESS_RW_INTERLEAVED);
snd_mask_set(access_mask, SND_PCM_ACCESS_RW_NONINTERLEAVED);
err = _snd_pcm_hw_param_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
access_mask);
if (err < 0)