Lines Matching defs:*
2 * Mask inlines
3 * Copyright (c) 2000 by Abramo Bagnara <abramo@alsa-project.org>
6 * This library is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU Lesser General Public License as
8 * published by the Free Software Foundation; either version 2.1 of
9 * the License, or (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <sys/types.h>
24 #define MASK_INLINE static inline
26 #define MASK_MAX SND_MASK_MAX
27 #define MASK_SIZE (MASK_MAX / 32)
29 #define MASK_OFS(i) ((i) >> 5)
30 #define MASK_BIT(i) (1U << ((i) & 31))
32 MASK_INLINE unsigned int ld2(u_int32_t v)
34 unsigned r = 0;
36 if (v >= 0x10000) {
37 v >>= 16;
38 r += 16;
40 if (v >= 0x100) {
41 v >>= 8;
42 r += 8;
44 if (v >= 0x10) {
45 v >>= 4;
46 r += 4;
48 if (v >= 4) {
49 v >>= 2;
50 r += 2;
52 if (v >= 2)
53 r++;
54 return r;
57 MASK_INLINE unsigned int hweight32(u_int32_t v)
59 v = (v & 0x55555555) + ((v >> 1) & 0x55555555);
60 v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
61 v = (v & 0x0F0F0F0F) + ((v >> 4) & 0x0F0F0F0F);
62 v = (v & 0x00FF00FF) + ((v >> 8) & 0x00FF00FF);
63 return (v & 0x0000FFFF) + ((v >> 16) & 0x0000FFFF);
66 MASK_INLINE size_t snd_mask_sizeof(void)
68 return sizeof(snd_mask_t);
71 MASK_INLINE void snd_mask_none(snd_mask_t *mask)
73 memset(mask, 0, sizeof(*mask));
76 MASK_INLINE void snd_mask_any(snd_mask_t *mask)
78 memset(mask, 0xff, MASK_SIZE * sizeof(u_int32_t));
81 MASK_INLINE int snd_mask_empty(const snd_mask_t *mask)
83 int i;
84 for (i = 0; i < MASK_SIZE; i++)
85 if (mask->bits[i])
86 return 0;
87 return 1;
90 MASK_INLINE int snd_mask_full(const snd_mask_t *mask)
92 int i;
93 for (i = 0; i < MASK_SIZE; i++)
94 if (mask->bits[i] != 0xffffffff)
95 return 0;
96 return 1;
99 MASK_INLINE unsigned int snd_mask_count(const snd_mask_t *mask)
101 int i, w = 0;
102 for (i = 0; i < MASK_SIZE; i++)
103 w += hweight32(mask->bits[i]);
104 return w;
107 MASK_INLINE unsigned int snd_mask_min(const snd_mask_t *mask)
109 int i;
110 assert(!snd_mask_empty(mask));
111 for (i = 0; i < MASK_SIZE; i++) {
112 if (mask->bits[i])
113 return ffs(mask->bits[i]) - 1 + (i << 5);
115 return 0;
118 MASK_INLINE unsigned int snd_mask_max(const snd_mask_t *mask)
120 int i;
121 assert(!snd_mask_empty(mask));
122 for (i = MASK_SIZE - 1; i >= 0; i--) {
123 if (mask->bits[i])
124 return ld2(mask->bits[i]) + (i << 5);
126 return 0;
129 MASK_INLINE void snd_mask_set(snd_mask_t *mask, unsigned int val)
131 assert(val <= SND_MASK_MAX);
132 mask->bits[MASK_OFS(val)] |= MASK_BIT(val);
135 MASK_INLINE void snd_mask_reset(snd_mask_t *mask, unsigned int val)
137 assert(val <= SND_MASK_MAX);
138 mask->bits[MASK_OFS(val)] &= ~MASK_BIT(val);
141 MASK_INLINE void snd_mask_set_range(snd_mask_t *mask, unsigned int from, unsigned int to)
143 unsigned int i;
144 assert(to <= SND_MASK_MAX && from <= to);
145 for (i = from; i <= to; i++)
146 mask->bits[MASK_OFS(i)] |= MASK_BIT(i);
149 MASK_INLINE void snd_mask_reset_range(snd_mask_t *mask, unsigned int from, unsigned int to)
151 unsigned int i;
152 assert(to <= SND_MASK_MAX && from <= to);
153 for (i = from; i <= to; i++)
154 mask->bits[MASK_OFS(i)] &= ~MASK_BIT(i);
157 MASK_INLINE void snd_mask_leave(snd_mask_t *mask, unsigned int val)
159 unsigned int v;
160 assert(val <= SND_MASK_MAX);
161 v = mask->bits[MASK_OFS(val)] & MASK_BIT(val);
162 snd_mask_none(mask);
163 mask->bits[MASK_OFS(val)] = v;
166 MASK_INLINE void snd_mask_intersect(snd_mask_t *mask, const snd_mask_t *v)
168 int i;
169 for (i = 0; i < MASK_SIZE; i++)
170 mask->bits[i] &= v->bits[i];
173 MASK_INLINE void snd_mask_union(snd_mask_t *mask, const snd_mask_t *v)
175 int i;
176 for (i = 0; i < MASK_SIZE; i++)
177 mask->bits[i] |= v->bits[i];
180 MASK_INLINE int snd_mask_eq(const snd_mask_t *mask, const snd_mask_t *v)
182 return ! memcmp(mask, v, MASK_SIZE * 4);
185 MASK_INLINE void snd_mask_copy(snd_mask_t *mask, const snd_mask_t *v)
187 *mask = *v;
190 MASK_INLINE int snd_mask_test(const snd_mask_t *mask, unsigned int val)
192 assert(val <= SND_MASK_MAX);
193 return mask->bits[MASK_OFS(val)] & MASK_BIT(val);
196 MASK_INLINE int snd_mask_single(const snd_mask_t *mask)
198 int i, c = 0;
199 assert(!snd_mask_empty(mask));
200 for (i = 0; i < MASK_SIZE; i++) {
201 if (! mask->bits[i])
202 continue;
203 if (mask->bits[i] & (mask->bits[i] - 1))
204 return 0;
205 if (c)
206 return 0;
207 c++;
209 return 1;
212 MASK_INLINE int snd_mask_refine(snd_mask_t *mask, const snd_mask_t *v)
214 snd_mask_t old;
215 if (snd_mask_empty(mask))
216 return -ENOENT;
217 snd_mask_copy(&old, mask);
218 snd_mask_intersect(mask, v);
219 if (snd_mask_empty(mask))
220 return -EINVAL;
221 return !snd_mask_eq(mask, &old);
224 MASK_INLINE int snd_mask_refine_first(snd_mask_t *mask)
226 if (snd_mask_empty(mask))
227 return -ENOENT;
228 if (snd_mask_single(mask))
229 return 0;
230 snd_mask_leave(mask, snd_mask_min(mask));
231 return 1;
234 MASK_INLINE int snd_mask_refine_last(snd_mask_t *mask)
236 if (snd_mask_empty(mask))
237 return -ENOENT;
238 if (snd_mask_single(mask))
239 return 0;
240 snd_mask_leave(mask, snd_mask_max(mask));
241 return 1;
244 MASK_INLINE int snd_mask_refine_min(snd_mask_t *mask, unsigned int val)
246 if (snd_mask_empty(mask))
247 return -ENOENT;
248 if (snd_mask_min(mask) >= val)
249 return 0;
250 snd_mask_reset_range(mask, 0, val - 1);
251 if (snd_mask_empty(mask))
252 return -EINVAL;
253 return 1;
256 MASK_INLINE int snd_mask_refine_max(snd_mask_t *mask, unsigned int val)
258 if (snd_mask_empty(mask))
259 return -ENOENT;
260 if (snd_mask_max(mask) <= val)
261 return 0;
262 snd_mask_reset_range(mask, val + 1, SND_MASK_MAX);
263 if (snd_mask_empty(mask))
264 return -EINVAL;
265 return 1;
268 MASK_INLINE int snd_mask_refine_set(snd_mask_t *mask, unsigned int val)
270 int changed;
271 if (snd_mask_empty(mask))
272 return -ENOENT;
273 changed = !snd_mask_single(mask);
274 snd_mask_leave(mask, val);
275 if (snd_mask_empty(mask))
276 return -EINVAL;
277 return changed;
280 MASK_INLINE int snd_mask_value(const snd_mask_t *mask)
282 assert(!snd_mask_empty(mask));
283 return snd_mask_min(mask);
286 MASK_INLINE int snd_mask_always_eq(const snd_mask_t *m1, const snd_mask_t *m2)
288 return snd_mask_single(m1) && snd_mask_single(m2) &&
289 snd_mask_value(m1) == snd_mask_value(m2);
292 MASK_INLINE int snd_mask_never_eq(const snd_mask_t *m1, const snd_mask_t *m2)
294 int i;
295 for (i = 0; i < MASK_SIZE; i++)
296 if (m1->bits[i] & m2->bits[i])
297 return 0;
298 return 1;