Branch data Line data Source code
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 : :
41 : : static inline unsigned int ld2(u_int32_t v)
42 : : {
43 : : unsigned r = 0;
44 : :
45 [ # # ]: 0 : if (v >= 0x10000) {
46 : 0 : v >>= 16;
47 : : r += 16;
48 : : }
49 [ # # ]: 0 : if (v >= 0x100) {
50 : 0 : v >>= 8;
51 : 0 : r += 8;
52 : : }
53 [ # # ]: 0 : if (v >= 0x10) {
54 : 0 : v >>= 4;
55 : 0 : r += 4;
56 : : }
57 [ # # ]: 0 : if (v >= 4) {
58 : 0 : v >>= 2;
59 : 0 : r += 2;
60 : : }
61 [ # # ]: 0 : if (v >= 2)
62 : 0 : r++;
63 : : return r;
64 : : }
65 : :
66 : : static inline size_t snd_mask_sizeof(void)
67 : : {
68 : : return sizeof(struct snd_mask);
69 : : }
70 : :
71 : : static inline void snd_mask_none(struct snd_mask *mask)
72 : : {
73 : 0 : memset(mask, 0, sizeof(*mask));
74 : : }
75 : :
76 : : static inline void snd_mask_any(struct snd_mask *mask)
77 : : {
78 : 0 : memset(mask, 0xff, SNDRV_MASK_SIZE * sizeof(u_int32_t));
79 : : }
80 : :
81 : : static inline int snd_mask_empty(const struct snd_mask *mask)
82 : : {
83 : : int i;
84 [ # # ][ # # ]: 0 : for (i = 0; i < SNDRV_MASK_SIZE; i++)
[ # # ]
85 [ # # ][ # # ]: 0 : if (mask->bits[i])
[ # # ]
86 : : return 0;
87 : : return 1;
88 : : }
89 : :
90 : : static inline unsigned int snd_mask_min(const struct snd_mask *mask)
91 : : {
92 : : int i;
93 [ # # ][ # # ]: 0 : for (i = 0; i < SNDRV_MASK_SIZE; i++) {
[ # # ][ # # ]
94 [ # # ][ # # ]: 0 : if (mask->bits[i])
[ # # ][ # # ]
95 : 0 : return ffs(mask->bits[i]) - 1 + (i << 5);
96 : : }
97 : : return 0;
98 : : }
99 : :
100 : : static inline unsigned int snd_mask_max(const struct snd_mask *mask)
101 : : {
102 : : int i;
103 [ # # ]: 0 : for (i = SNDRV_MASK_SIZE - 1; i >= 0; i--) {
104 [ # # ]: 0 : if (mask->bits[i])
105 : 0 : return ld2(mask->bits[i]) + (i << 5);
106 : : }
107 : : return 0;
108 : : }
109 : :
110 : : static inline void snd_mask_set(struct snd_mask *mask, unsigned int val)
111 : : {
112 : : mask->bits[MASK_OFS(val)] |= MASK_BIT(val);
113 : : }
114 : :
115 : : static inline void snd_mask_reset(struct snd_mask *mask, unsigned int val)
116 : : {
117 : 0 : mask->bits[MASK_OFS(val)] &= ~MASK_BIT(val);
118 : : }
119 : :
120 : : static inline void snd_mask_set_range(struct snd_mask *mask,
121 : : unsigned int from, unsigned int to)
122 : : {
123 : : unsigned int i;
124 : : for (i = from; i <= to; i++)
125 : : mask->bits[MASK_OFS(i)] |= MASK_BIT(i);
126 : : }
127 : :
128 : : static inline void snd_mask_reset_range(struct snd_mask *mask,
129 : : unsigned int from, unsigned int to)
130 : : {
131 : : unsigned int i;
132 : : for (i = from; i <= to; i++)
133 : : mask->bits[MASK_OFS(i)] &= ~MASK_BIT(i);
134 : : }
135 : :
136 : : static inline void snd_mask_leave(struct snd_mask *mask, unsigned int val)
137 : : {
138 : : unsigned int v;
139 : 0 : v = mask->bits[MASK_OFS(val)] & MASK_BIT(val);
140 : : snd_mask_none(mask);
141 : 0 : mask->bits[MASK_OFS(val)] = v;
142 : : }
143 : :
144 : : static inline void snd_mask_intersect(struct snd_mask *mask,
145 : : const struct snd_mask *v)
146 : : {
147 : : int i;
148 [ # # ][ # # ]: 0 : for (i = 0; i < SNDRV_MASK_SIZE; i++)
149 : 0 : mask->bits[i] &= v->bits[i];
150 : : }
151 : :
152 : : static inline int snd_mask_eq(const struct snd_mask *mask,
153 : : const struct snd_mask *v)
154 : : {
155 : 0 : return ! memcmp(mask, v, SNDRV_MASK_SIZE * sizeof(u_int32_t));
156 : : }
157 : :
158 : : static inline void snd_mask_copy(struct snd_mask *mask,
159 : : const struct snd_mask *v)
160 : : {
161 : 0 : *mask = *v;
162 : : }
163 : :
164 : : static inline int snd_mask_test(const struct snd_mask *mask, unsigned int val)
165 : : {
166 : 0 : return mask->bits[MASK_OFS(val)] & MASK_BIT(val);
167 : : }
168 : :
169 : : static inline int snd_mask_single(const struct snd_mask *mask)
170 : : {
171 : : int i, c = 0;
172 [ # # ][ # # ]: 0 : for (i = 0; i < SNDRV_MASK_SIZE; i++) {
[ # # ]
173 [ # # ][ # # ]: 0 : if (! mask->bits[i])
[ # # ]
174 : 0 : continue;
175 [ # # ][ # # ]: 0 : if (mask->bits[i] & (mask->bits[i] - 1))
[ # # ]
176 : : return 0;
177 [ # # ][ # # ]: 0 : if (c)
[ # # ]
178 : : return 0;
179 : 0 : c++;
180 : : }
181 : : return 1;
182 : : }
183 : :
184 : : static inline int snd_mask_refine(struct snd_mask *mask,
185 : : const struct snd_mask *v)
186 : : {
187 : : struct snd_mask old;
188 : : snd_mask_copy(&old, mask);
189 : : snd_mask_intersect(mask, v);
190 [ # # ][ # # ]: 0 : if (snd_mask_empty(mask))
191 : : return -EINVAL;
192 : 0 : return !snd_mask_eq(mask, &old);
193 : : }
194 : :
195 : : static inline int snd_mask_refine_first(struct snd_mask *mask)
196 : : {
197 [ # # ]: 0 : if (snd_mask_single(mask))
198 : : return 0;
199 : : snd_mask_leave(mask, snd_mask_min(mask));
200 : : return 1;
201 : : }
202 : :
203 : : static inline int snd_mask_refine_last(struct snd_mask *mask)
204 : : {
205 [ # # ]: 0 : if (snd_mask_single(mask))
206 : : return 0;
207 : : snd_mask_leave(mask, snd_mask_max(mask));
208 : : return 1;
209 : : }
210 : :
211 : : static inline int snd_mask_refine_min(struct snd_mask *mask, unsigned int val)
212 : : {
213 : : if (snd_mask_min(mask) >= val)
214 : : return 0;
215 : : snd_mask_reset_range(mask, 0, val - 1);
216 : : if (snd_mask_empty(mask))
217 : : return -EINVAL;
218 : : return 1;
219 : : }
220 : :
221 : : static inline int snd_mask_refine_max(struct snd_mask *mask, unsigned int val)
222 : : {
223 : : if (snd_mask_max(mask) <= val)
224 : : return 0;
225 : : snd_mask_reset_range(mask, val + 1, SNDRV_MASK_BITS);
226 : : if (snd_mask_empty(mask))
227 : : return -EINVAL;
228 : : return 1;
229 : : }
230 : :
231 : : static inline int snd_mask_refine_set(struct snd_mask *mask, unsigned int val)
232 : : {
233 : : int changed;
234 : : changed = !snd_mask_single(mask);
235 : : snd_mask_leave(mask, val);
236 : : if (snd_mask_empty(mask))
237 : : return -EINVAL;
238 : : return changed;
239 : : }
240 : :
241 : : static inline int snd_mask_value(const struct snd_mask *mask)
242 : : {
243 : 0 : return snd_mask_min(mask);
244 : : }
245 : :
246 : : static inline void snd_interval_any(struct snd_interval *i)
247 : : {
248 : 0 : i->min = 0;
249 : 0 : i->openmin = 0;
250 : 0 : i->max = UINT_MAX;
251 : 0 : i->openmax = 0;
252 : 0 : i->integer = 0;
253 : 0 : i->empty = 0;
254 : : }
255 : :
256 : : static inline void snd_interval_none(struct snd_interval *i)
257 : : {
258 : 0 : i->empty = 1;
259 : : }
260 : :
261 : : static inline int snd_interval_checkempty(const struct snd_interval *i)
262 : : {
263 [ # # ][ # # ]: 0 : return (i->min > i->max ||
[ # # ][ # # ]
264 [ # # ][ # # ]: 0 : (i->min == i->max && (i->openmin || i->openmax)));
265 : : }
266 : :
267 : : static inline int snd_interval_empty(const struct snd_interval *i)
268 : : {
269 : 0 : return i->empty;
270 : : }
271 : :
272 : : static inline int snd_interval_single(const struct snd_interval *i)
273 : : {
274 [ # # ][ # # ]: 0 : return (i->min == i->max ||
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
275 [ # # ][ # # ]: 0 : (i->min + 1 == i->max && i->openmax));
[ # # ][ # # ]
[ # # ][ # # ]
276 : : }
277 : :
278 : : static inline int snd_interval_value(const struct snd_interval *i)
279 : : {
280 : 0 : return i->min;
281 : : }
282 : :
283 : : static inline int snd_interval_min(const struct snd_interval *i)
284 : : {
285 : : return i->min;
286 : : }
287 : :
288 : : static inline int snd_interval_max(const struct snd_interval *i)
289 : : {
290 : : unsigned int v;
291 : 0 : v = i->max;
292 [ # # ]: 0 : if (i->openmax)
293 : 0 : v--;
294 : : return v;
295 : : }
296 : :
297 : : static inline int snd_interval_test(const struct snd_interval *i, unsigned int val)
298 : : {
299 [ # # ][ # # ]: 0 : return !((i->min > val || (i->min == val && i->openmin) ||
[ # # ][ # # ]
[ # # ]
300 [ # # ]: 0 : i->max < val || (i->max == val && i->openmax)));
301 : : }
302 : :
303 : : static inline void snd_interval_copy(struct snd_interval *d, const struct snd_interval *s)
304 : : {
305 : : *d = *s;
306 : : }
307 : :
308 : : static inline int snd_interval_setinteger(struct snd_interval *i)
309 : : {
310 [ # # ][ # # ]: 0 : if (i->integer)
[ # # ][ # # ]
[ # # ]
311 : : return 0;
312 [ # # ][ # # ]: 0 : if (i->openmin && i->openmax && i->min == i->max)
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
313 : : return -EINVAL;
314 : 0 : i->integer = 1;
315 : : return 1;
316 : : }
317 : :
318 : : static inline int snd_interval_eq(const struct snd_interval *i1, const struct snd_interval *i2)
319 : : {
320 : : if (i1->empty)
321 : : return i2->empty;
322 : : if (i2->empty)
323 : : return i1->empty;
324 : : return i1->min == i2->min && i1->openmin == i2->openmin &&
325 : : i1->max == i2->max && i1->openmax == i2->openmax;
326 : : }
327 : :
328 : : static inline unsigned int add(unsigned int a, unsigned int b)
329 : : {
330 : : if (a >= UINT_MAX - b)
331 : : return UINT_MAX;
332 : : return a + b;
333 : : }
334 : :
335 : : static inline unsigned int sub(unsigned int a, unsigned int b)
336 : : {
337 : : if (a > b)
338 : : return a - b;
339 : : return 0;
340 : : }
341 : :
342 : : #define params_access(p) ((__force snd_pcm_access_t)\
343 : : snd_mask_min(hw_param_mask_c((p), SNDRV_PCM_HW_PARAM_ACCESS)))
344 : : #define params_format(p) ((__force snd_pcm_format_t)\
345 : : snd_mask_min(hw_param_mask_c((p), SNDRV_PCM_HW_PARAM_FORMAT)))
346 : : #define params_subformat(p) \
347 : : snd_mask_min(hw_param_mask_c((p), SNDRV_PCM_HW_PARAM_SUBFORMAT))
348 : :
349 : : static inline unsigned int
350 : : params_period_bytes(const struct snd_pcm_hw_params *p)
351 : : {
352 : : return (params_period_size(p) *
353 : : snd_pcm_format_physical_width(params_format(p)) *
354 : : params_channels(p)) / 8;
355 : : }
356 : :
357 : : #endif /* __SOUND_PCM_PARAMS_H */
|
