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