1 #ifndef __SOUND_PCM_PARAMS_H
2 #define __SOUND_PCM_PARAMS_H
3 
4 /*
5  *  PCM params helpers
6  *  Copyright (c) by Abramo Bagnara <abramo@alsa-project.org>
7  *
8  *
9  *   This program is free software; you can redistribute it and/or modify
10  *   it under the terms of the GNU General Public License as published by
11  *   the Free Software Foundation; either version 2 of the License, or
12  *   (at your option) any later version.
13  *
14  *   This program is distributed in the hope that it will be useful,
15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  *   GNU General Public License for more details.
18  *
19  *   You should have received a copy of the GNU General Public License
20  *   along with this program; if not, write to the Free Software
21  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
22  *
23  */
24 
25 #include <sound/pcm.h>
26 
27 int snd_pcm_hw_param_first(struct snd_pcm_substream *pcm,
28 			   struct snd_pcm_hw_params *params,
29 			   snd_pcm_hw_param_t var, int *dir);
30 int snd_pcm_hw_param_last(struct snd_pcm_substream *pcm,
31 			  struct snd_pcm_hw_params *params,
32 			  snd_pcm_hw_param_t var, int *dir);
33 int snd_pcm_hw_param_value(const struct snd_pcm_hw_params *params,
34 			   snd_pcm_hw_param_t var, int *dir);
35 
36 #define SNDRV_MASK_BITS	64	/* we use so far 64bits only */
37 #define SNDRV_MASK_SIZE	(SNDRV_MASK_BITS / 32)
38 #define MASK_OFS(i)	((i) >> 5)
39 #define MASK_BIT(i)	(1U << ((i) & 31))
40 
snd_mask_sizeof(void)41 static inline size_t snd_mask_sizeof(void)
42 {
43 	return sizeof(struct snd_mask);
44 }
45 
snd_mask_none(struct snd_mask * mask)46 static inline void snd_mask_none(struct snd_mask *mask)
47 {
48 	memset(mask, 0, sizeof(*mask));
49 }
50 
snd_mask_any(struct snd_mask * mask)51 static inline void snd_mask_any(struct snd_mask *mask)
52 {
53 	memset(mask, 0xff, SNDRV_MASK_SIZE * sizeof(u_int32_t));
54 }
55 
snd_mask_empty(const struct snd_mask * mask)56 static inline int snd_mask_empty(const struct snd_mask *mask)
57 {
58 	int i;
59 	for (i = 0; i < SNDRV_MASK_SIZE; i++)
60 		if (mask->bits[i])
61 			return 0;
62 	return 1;
63 }
64 
snd_mask_min(const struct snd_mask * mask)65 static inline unsigned int snd_mask_min(const struct snd_mask *mask)
66 {
67 	int i;
68 	for (i = 0; i < SNDRV_MASK_SIZE; i++) {
69 		if (mask->bits[i])
70 			return __ffs(mask->bits[i]) + (i << 5);
71 	}
72 	return 0;
73 }
74 
snd_mask_max(const struct snd_mask * mask)75 static inline unsigned int snd_mask_max(const struct snd_mask *mask)
76 {
77 	int i;
78 	for (i = SNDRV_MASK_SIZE - 1; i >= 0; i--) {
79 		if (mask->bits[i])
80 			return __fls(mask->bits[i]) + (i << 5);
81 	}
82 	return 0;
83 }
84 
snd_mask_set(struct snd_mask * mask,unsigned int val)85 static inline void snd_mask_set(struct snd_mask *mask, unsigned int val)
86 {
87 	mask->bits[MASK_OFS(val)] |= MASK_BIT(val);
88 }
89 
90 /* Most of drivers need only this one */
snd_mask_set_format(struct snd_mask * mask,snd_pcm_format_t format)91 static inline void snd_mask_set_format(struct snd_mask *mask,
92 				       snd_pcm_format_t format)
93 {
94 	snd_mask_set(mask, (__force unsigned int)format);
95 }
96 
snd_mask_reset(struct snd_mask * mask,unsigned int val)97 static inline void snd_mask_reset(struct snd_mask *mask, unsigned int val)
98 {
99 	mask->bits[MASK_OFS(val)] &= ~MASK_BIT(val);
100 }
101 
snd_mask_set_range(struct snd_mask * mask,unsigned int from,unsigned int to)102 static inline void snd_mask_set_range(struct snd_mask *mask,
103 				      unsigned int from, unsigned int to)
104 {
105 	unsigned int i;
106 	for (i = from; i <= to; i++)
107 		mask->bits[MASK_OFS(i)] |= MASK_BIT(i);
108 }
109 
snd_mask_reset_range(struct snd_mask * mask,unsigned int from,unsigned int to)110 static inline void snd_mask_reset_range(struct snd_mask *mask,
111 					unsigned int from, unsigned int to)
112 {
113 	unsigned int i;
114 	for (i = from; i <= to; i++)
115 		mask->bits[MASK_OFS(i)] &= ~MASK_BIT(i);
116 }
117 
snd_mask_leave(struct snd_mask * mask,unsigned int val)118 static inline void snd_mask_leave(struct snd_mask *mask, unsigned int val)
119 {
120 	unsigned int v;
121 	v = mask->bits[MASK_OFS(val)] & MASK_BIT(val);
122 	snd_mask_none(mask);
123 	mask->bits[MASK_OFS(val)] = v;
124 }
125 
snd_mask_intersect(struct snd_mask * mask,const struct snd_mask * v)126 static inline void snd_mask_intersect(struct snd_mask *mask,
127 				      const struct snd_mask *v)
128 {
129 	int i;
130 	for (i = 0; i < SNDRV_MASK_SIZE; i++)
131 		mask->bits[i] &= v->bits[i];
132 }
133 
snd_mask_eq(const struct snd_mask * mask,const struct snd_mask * v)134 static inline int snd_mask_eq(const struct snd_mask *mask,
135 			      const struct snd_mask *v)
136 {
137 	return ! memcmp(mask, v, SNDRV_MASK_SIZE * sizeof(u_int32_t));
138 }
139 
snd_mask_copy(struct snd_mask * mask,const struct snd_mask * v)140 static inline void snd_mask_copy(struct snd_mask *mask,
141 				 const struct snd_mask *v)
142 {
143 	*mask = *v;
144 }
145 
snd_mask_test(const struct snd_mask * mask,unsigned int val)146 static inline int snd_mask_test(const struct snd_mask *mask, unsigned int val)
147 {
148 	return mask->bits[MASK_OFS(val)] & MASK_BIT(val);
149 }
150 
snd_mask_single(const struct snd_mask * mask)151 static inline int snd_mask_single(const struct snd_mask *mask)
152 {
153 	int i, c = 0;
154 	for (i = 0; i < SNDRV_MASK_SIZE; i++) {
155 		if (! mask->bits[i])
156 			continue;
157 		if (mask->bits[i] & (mask->bits[i] - 1))
158 			return 0;
159 		if (c)
160 			return 0;
161 		c++;
162 	}
163 	return 1;
164 }
165 
snd_mask_refine(struct snd_mask * mask,const struct snd_mask * v)166 static inline int snd_mask_refine(struct snd_mask *mask,
167 				  const struct snd_mask *v)
168 {
169 	struct snd_mask old;
170 	snd_mask_copy(&old, mask);
171 	snd_mask_intersect(mask, v);
172 	if (snd_mask_empty(mask))
173 		return -EINVAL;
174 	return !snd_mask_eq(mask, &old);
175 }
176 
snd_mask_refine_first(struct snd_mask * mask)177 static inline int snd_mask_refine_first(struct snd_mask *mask)
178 {
179 	if (snd_mask_single(mask))
180 		return 0;
181 	snd_mask_leave(mask, snd_mask_min(mask));
182 	return 1;
183 }
184 
snd_mask_refine_last(struct snd_mask * mask)185 static inline int snd_mask_refine_last(struct snd_mask *mask)
186 {
187 	if (snd_mask_single(mask))
188 		return 0;
189 	snd_mask_leave(mask, snd_mask_max(mask));
190 	return 1;
191 }
192 
snd_mask_refine_min(struct snd_mask * mask,unsigned int val)193 static inline int snd_mask_refine_min(struct snd_mask *mask, unsigned int val)
194 {
195 	if (snd_mask_min(mask) >= val)
196 		return 0;
197 	snd_mask_reset_range(mask, 0, val - 1);
198 	if (snd_mask_empty(mask))
199 		return -EINVAL;
200 	return 1;
201 }
202 
snd_mask_refine_max(struct snd_mask * mask,unsigned int val)203 static inline int snd_mask_refine_max(struct snd_mask *mask, unsigned int val)
204 {
205 	if (snd_mask_max(mask) <= val)
206 		return 0;
207 	snd_mask_reset_range(mask, val + 1, SNDRV_MASK_BITS);
208 	if (snd_mask_empty(mask))
209 		return -EINVAL;
210 	return 1;
211 }
212 
snd_mask_refine_set(struct snd_mask * mask,unsigned int val)213 static inline int snd_mask_refine_set(struct snd_mask *mask, unsigned int val)
214 {
215 	int changed;
216 	changed = !snd_mask_single(mask);
217 	snd_mask_leave(mask, val);
218 	if (snd_mask_empty(mask))
219 		return -EINVAL;
220 	return changed;
221 }
222 
snd_mask_value(const struct snd_mask * mask)223 static inline int snd_mask_value(const struct snd_mask *mask)
224 {
225 	return snd_mask_min(mask);
226 }
227 
snd_interval_any(struct snd_interval * i)228 static inline void snd_interval_any(struct snd_interval *i)
229 {
230 	i->min = 0;
231 	i->openmin = 0;
232 	i->max = UINT_MAX;
233 	i->openmax = 0;
234 	i->integer = 0;
235 	i->empty = 0;
236 }
237 
snd_interval_none(struct snd_interval * i)238 static inline void snd_interval_none(struct snd_interval *i)
239 {
240 	i->empty = 1;
241 }
242 
snd_interval_checkempty(const struct snd_interval * i)243 static inline int snd_interval_checkempty(const struct snd_interval *i)
244 {
245 	return (i->min > i->max ||
246 		(i->min == i->max && (i->openmin || i->openmax)));
247 }
248 
snd_interval_empty(const struct snd_interval * i)249 static inline int snd_interval_empty(const struct snd_interval *i)
250 {
251 	return i->empty;
252 }
253 
snd_interval_single(const struct snd_interval * i)254 static inline int snd_interval_single(const struct snd_interval *i)
255 {
256 	return (i->min == i->max ||
257 		(i->min + 1 == i->max && (i->openmin || i->openmax)));
258 }
259 
snd_interval_value(const struct snd_interval * i)260 static inline int snd_interval_value(const struct snd_interval *i)
261 {
262 	if (i->openmin && !i->openmax)
263 		return i->max;
264 	return i->min;
265 }
266 
snd_interval_min(const struct snd_interval * i)267 static inline int snd_interval_min(const struct snd_interval *i)
268 {
269 	return i->min;
270 }
271 
snd_interval_max(const struct snd_interval * i)272 static inline int snd_interval_max(const struct snd_interval *i)
273 {
274 	unsigned int v;
275 	v = i->max;
276 	if (i->openmax)
277 		v--;
278 	return v;
279 }
280 
snd_interval_test(const struct snd_interval * i,unsigned int val)281 static inline int snd_interval_test(const struct snd_interval *i, unsigned int val)
282 {
283 	return !((i->min > val || (i->min == val && i->openmin) ||
284 		  i->max < val || (i->max == val && i->openmax)));
285 }
286 
snd_interval_copy(struct snd_interval * d,const struct snd_interval * s)287 static inline void snd_interval_copy(struct snd_interval *d, const struct snd_interval *s)
288 {
289 	*d = *s;
290 }
291 
snd_interval_setinteger(struct snd_interval * i)292 static inline int snd_interval_setinteger(struct snd_interval *i)
293 {
294 	if (i->integer)
295 		return 0;
296 	if (i->openmin && i->openmax && i->min == i->max)
297 		return -EINVAL;
298 	i->integer = 1;
299 	return 1;
300 }
301 
snd_interval_eq(const struct snd_interval * i1,const struct snd_interval * i2)302 static inline int snd_interval_eq(const struct snd_interval *i1, const struct snd_interval *i2)
303 {
304 	if (i1->empty)
305 		return i2->empty;
306 	if (i2->empty)
307 		return i1->empty;
308 	return i1->min == i2->min && i1->openmin == i2->openmin &&
309 		i1->max == i2->max && i1->openmax == i2->openmax;
310 }
311 
312 /**
313  * params_access - get the access type from the hw params
314  * @p: hw params
315  */
params_access(const struct snd_pcm_hw_params * p)316 static inline snd_pcm_access_t params_access(const struct snd_pcm_hw_params *p)
317 {
318 	return (__force snd_pcm_access_t)snd_mask_min(hw_param_mask_c(p,
319 		SNDRV_PCM_HW_PARAM_ACCESS));
320 }
321 
322 /**
323  * params_format - get the sample format from the hw params
324  * @p: hw params
325  */
params_format(const struct snd_pcm_hw_params * p)326 static inline snd_pcm_format_t params_format(const struct snd_pcm_hw_params *p)
327 {
328 	return (__force snd_pcm_format_t)snd_mask_min(hw_param_mask_c(p,
329 		SNDRV_PCM_HW_PARAM_FORMAT));
330 }
331 
332 /**
333  * params_subformat - get the sample subformat from the hw params
334  * @p: hw params
335  */
336 static inline snd_pcm_subformat_t
params_subformat(const struct snd_pcm_hw_params * p)337 params_subformat(const struct snd_pcm_hw_params *p)
338 {
339 	return (__force snd_pcm_subformat_t)snd_mask_min(hw_param_mask_c(p,
340 		SNDRV_PCM_HW_PARAM_SUBFORMAT));
341 }
342 
343 /**
344  * params_period_bytes - get the period size (in bytes) from the hw params
345  * @p: hw params
346  */
347 static inline unsigned int
params_period_bytes(const struct snd_pcm_hw_params * p)348 params_period_bytes(const struct snd_pcm_hw_params *p)
349 {
350 	return hw_param_interval_c(p, SNDRV_PCM_HW_PARAM_PERIOD_BYTES)->min;
351 }
352 
353 /**
354  * params_width - get the number of bits of the sample format from the hw params
355  * @p: hw params
356  *
357  * This function returns the number of bits per sample that the selected sample
358  * format of the hw params has.
359  */
params_width(const struct snd_pcm_hw_params * p)360 static inline int params_width(const struct snd_pcm_hw_params *p)
361 {
362 	return snd_pcm_format_width(params_format(p));
363 }
364 
365 /*
366  * params_physical_width - get the storage size of the sample format from the hw params
367  * @p: hw params
368  *
369  * This functions returns the number of bits per sample that the selected sample
370  * format of the hw params takes up in memory. This will be equal or larger than
371  * params_width().
372  */
params_physical_width(const struct snd_pcm_hw_params * p)373 static inline int params_physical_width(const struct snd_pcm_hw_params *p)
374 {
375 	return snd_pcm_format_physical_width(params_format(p));
376 }
377 
378 static inline void
params_set_format(struct snd_pcm_hw_params * p,snd_pcm_format_t fmt)379 params_set_format(struct snd_pcm_hw_params *p, snd_pcm_format_t fmt)
380 {
381 	snd_mask_set_format(hw_param_mask(p, SNDRV_PCM_HW_PARAM_FORMAT), fmt);
382 }
383 
384 #endif /* __SOUND_PCM_PARAMS_H */
385