1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 #ifndef __SOUND_PCM_PARAMS_H
3 #define __SOUND_PCM_PARAMS_H
7 * Copyright (c) by Abramo Bagnara <abramo@alsa-project.org>
10 #include <sound/pcm.h>
12 int snd_pcm_hw_param_first(struct snd_pcm_substream *pcm,
13 struct snd_pcm_hw_params *params,
14 snd_pcm_hw_param_t var, int *dir);
15 int snd_pcm_hw_param_last(struct snd_pcm_substream *pcm,
16 struct snd_pcm_hw_params *params,
17 snd_pcm_hw_param_t var, int *dir);
18 int snd_pcm_hw_param_value(const struct snd_pcm_hw_params *params,
19 snd_pcm_hw_param_t var, int *dir);
21 #define SNDRV_MASK_BITS 64 /* we use so far 64bits only */
22 #define SNDRV_MASK_SIZE (SNDRV_MASK_BITS / 32)
23 #define MASK_OFS(i) ((i) >> 5)
24 #define MASK_BIT(i) (1U << ((i) & 31))
26 static inline size_t snd_mask_sizeof(void)
28 return sizeof(struct snd_mask);
31 static inline void snd_mask_none(struct snd_mask *mask)
33 memset(mask, 0, sizeof(*mask));
36 static inline void snd_mask_any(struct snd_mask *mask)
38 memset(mask, 0xff, SNDRV_MASK_SIZE * sizeof(u_int32_t));
41 static inline int snd_mask_empty(const struct snd_mask *mask)
44 for (i = 0; i < SNDRV_MASK_SIZE; i++)
50 static inline unsigned int snd_mask_min(const struct snd_mask *mask)
53 for (i = 0; i < SNDRV_MASK_SIZE; i++) {
55 return __ffs(mask->bits[i]) + (i << 5);
60 static inline unsigned int snd_mask_max(const struct snd_mask *mask)
63 for (i = SNDRV_MASK_SIZE - 1; i >= 0; i--) {
65 return __fls(mask->bits[i]) + (i << 5);
70 static inline void snd_mask_set(struct snd_mask *mask, unsigned int val)
72 mask->bits[MASK_OFS(val)] |= MASK_BIT(val);
75 /* Most of drivers need only this one */
76 static inline void snd_mask_set_format(struct snd_mask *mask,
77 snd_pcm_format_t format)
79 snd_mask_set(mask, (__force unsigned int)format);
82 static inline void snd_mask_reset(struct snd_mask *mask, unsigned int val)
84 mask->bits[MASK_OFS(val)] &= ~MASK_BIT(val);
87 static inline void snd_mask_set_range(struct snd_mask *mask,
88 unsigned int from, unsigned int to)
91 for (i = from; i <= to; i++)
92 mask->bits[MASK_OFS(i)] |= MASK_BIT(i);
95 static inline void snd_mask_reset_range(struct snd_mask *mask,
96 unsigned int from, unsigned int to)
99 for (i = from; i <= to; i++)
100 mask->bits[MASK_OFS(i)] &= ~MASK_BIT(i);
103 static inline void snd_mask_leave(struct snd_mask *mask, unsigned int val)
106 v = mask->bits[MASK_OFS(val)] & MASK_BIT(val);
108 mask->bits[MASK_OFS(val)] = v;
111 static inline void snd_mask_intersect(struct snd_mask *mask,
112 const struct snd_mask *v)
115 for (i = 0; i < SNDRV_MASK_SIZE; i++)
116 mask->bits[i] &= v->bits[i];
119 static inline int snd_mask_eq(const struct snd_mask *mask,
120 const struct snd_mask *v)
122 return ! memcmp(mask, v, SNDRV_MASK_SIZE * sizeof(u_int32_t));
125 static inline void snd_mask_copy(struct snd_mask *mask,
126 const struct snd_mask *v)
131 static inline int snd_mask_test(const struct snd_mask *mask, unsigned int val)
133 return mask->bits[MASK_OFS(val)] & MASK_BIT(val);
136 /* Most of drivers need only this one */
137 static inline int snd_mask_test_format(const struct snd_mask *mask,
138 snd_pcm_format_t format)
140 return snd_mask_test(mask, (__force unsigned int)format);
143 static inline int snd_mask_single(const struct snd_mask *mask)
146 for (i = 0; i < SNDRV_MASK_SIZE; i++) {
149 if (mask->bits[i] & (mask->bits[i] - 1))
158 static inline int snd_mask_refine(struct snd_mask *mask,
159 const struct snd_mask *v)
162 snd_mask_copy(&old, mask);
163 snd_mask_intersect(mask, v);
164 if (snd_mask_empty(mask))
166 return !snd_mask_eq(mask, &old);
169 static inline int snd_mask_refine_first(struct snd_mask *mask)
171 if (snd_mask_single(mask))
173 snd_mask_leave(mask, snd_mask_min(mask));
177 static inline int snd_mask_refine_last(struct snd_mask *mask)
179 if (snd_mask_single(mask))
181 snd_mask_leave(mask, snd_mask_max(mask));
185 static inline int snd_mask_refine_min(struct snd_mask *mask, unsigned int val)
187 if (snd_mask_min(mask) >= val)
189 snd_mask_reset_range(mask, 0, val - 1);
190 if (snd_mask_empty(mask))
195 static inline int snd_mask_refine_max(struct snd_mask *mask, unsigned int val)
197 if (snd_mask_max(mask) <= val)
199 snd_mask_reset_range(mask, val + 1, SNDRV_MASK_BITS);
200 if (snd_mask_empty(mask))
205 static inline int snd_mask_refine_set(struct snd_mask *mask, unsigned int val)
208 changed = !snd_mask_single(mask);
209 snd_mask_leave(mask, val);
210 if (snd_mask_empty(mask))
215 static inline int snd_mask_value(const struct snd_mask *mask)
217 return snd_mask_min(mask);
220 static inline void snd_interval_any(struct snd_interval *i)
230 static inline void snd_interval_none(struct snd_interval *i)
235 static inline int snd_interval_checkempty(const struct snd_interval *i)
237 return (i->min > i->max ||
238 (i->min == i->max && (i->openmin || i->openmax)));
241 static inline int snd_interval_empty(const struct snd_interval *i)
246 static inline int snd_interval_single(const struct snd_interval *i)
248 return (i->min == i->max ||
249 (i->min + 1 == i->max && (i->openmin || i->openmax)));
252 static inline int snd_interval_value(const struct snd_interval *i)
254 if (i->openmin && !i->openmax)
259 static inline int snd_interval_min(const struct snd_interval *i)
264 static inline int snd_interval_max(const struct snd_interval *i)
273 static inline int snd_interval_test(const struct snd_interval *i, unsigned int val)
275 return !((i->min > val || (i->min == val && i->openmin) ||
276 i->max < val || (i->max == val && i->openmax)));
279 static inline void snd_interval_copy(struct snd_interval *d, const struct snd_interval *s)
284 static inline int snd_interval_setinteger(struct snd_interval *i)
288 if (i->openmin && i->openmax && i->min == i->max)
294 static inline int snd_interval_eq(const struct snd_interval *i1, const struct snd_interval *i2)
300 return i1->min == i2->min && i1->openmin == i2->openmin &&
301 i1->max == i2->max && i1->openmax == i2->openmax;
305 * params_access - get the access type from the hw params
308 static inline snd_pcm_access_t params_access(const struct snd_pcm_hw_params *p)
310 return (__force snd_pcm_access_t)snd_mask_min(hw_param_mask_c(p,
311 SNDRV_PCM_HW_PARAM_ACCESS));
315 * params_format - get the sample format from the hw params
318 static inline snd_pcm_format_t params_format(const struct snd_pcm_hw_params *p)
320 return (__force snd_pcm_format_t)snd_mask_min(hw_param_mask_c(p,
321 SNDRV_PCM_HW_PARAM_FORMAT));
325 * params_subformat - get the sample subformat from the hw params
328 static inline snd_pcm_subformat_t
329 params_subformat(const struct snd_pcm_hw_params *p)
331 return (__force snd_pcm_subformat_t)snd_mask_min(hw_param_mask_c(p,
332 SNDRV_PCM_HW_PARAM_SUBFORMAT));
336 * params_period_bytes - get the period size (in bytes) from the hw params
339 static inline unsigned int
340 params_period_bytes(const struct snd_pcm_hw_params *p)
342 return hw_param_interval_c(p, SNDRV_PCM_HW_PARAM_PERIOD_BYTES)->min;
346 * params_width - get the number of bits of the sample format from the hw params
349 * This function returns the number of bits per sample that the selected sample
350 * format of the hw params has.
352 static inline int params_width(const struct snd_pcm_hw_params *p)
354 return snd_pcm_format_width(params_format(p));
358 * params_physical_width - get the storage size of the sample format from the hw params
361 * This functions returns the number of bits per sample that the selected sample
362 * format of the hw params takes up in memory. This will be equal or larger than
365 static inline int params_physical_width(const struct snd_pcm_hw_params *p)
367 return snd_pcm_format_physical_width(params_format(p));
371 params_set_format(struct snd_pcm_hw_params *p, snd_pcm_format_t fmt)
373 snd_mask_set_format(hw_param_mask(p, SNDRV_PCM_HW_PARAM_FORMAT), fmt);
376 #endif /* __SOUND_PCM_PARAMS_H */