src/pcm/mask_inline.h

   1 /*
   2  *  Mask inlines
   3  *  Copyright (c) 2000 by Abramo Bagnara <abramo@alsa-project.org>
   4  *
   5  *
   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.
  10  *
  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.
  15  *
  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
  19  *
  20  */
  21
  22 #include <sys/types.h>
  23
  24 #define MASK_INLINE static inline
  25
  26 #define MASK_MAX SND_MASK_MAX
  27 #define MASK_SIZE (MASK_MAX / 32)
  28
  29 #define MASK_OFS(i)     ((i) >> 5)
  30 #define MASK_BIT(i)     (1U << ((i) & 31))
  31
  32 MASK_INLINE unsigned int ld2(u_int32_t v)
  33 {
  34         unsigned r = 0;
  35
  36         if (v >= 0x10000) {
  37                 v >>= 16;
  38                 r += 16;
  39         }
  40         if (v >= 0x100) {
  41                 v >>= 8;
  42                 r += 8;
  43         }
  44         if (v >= 0x10) {
  45                 v >>= 4;
  46                 r += 4;
  47         }
  48         if (v >= 4) {
  49                 v >>= 2;
  50                 r += 2;
  51         }
  52         if (v >= 2)
  53                 r++;
  54         return r;
  55 }
  56
  57 MASK_INLINE unsigned int hweight32(u_int32_t v)
  58 {
  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);
  64 }
  65
  66 MASK_INLINE size_t snd_mask_sizeof(void)
  67 {
  68         return sizeof(snd_mask_t);
  69 }
  70
  71 MASK_INLINE void snd_mask_none(snd_mask_t *mask)
  72 {
  73         memset(mask, 0, sizeof(*mask));
  74 }
  75
  76 MASK_INLINE void snd_mask_any(snd_mask_t *mask)
  77 {
  78         memset(mask, 0xff, MASK_SIZE * sizeof(u_int32_t));
  79 }
  80
  81 MASK_INLINE int snd_mask_empty(const snd_mask_t *mask)
  82 {
  83         int i;
  84         for (i = 0; i < MASK_SIZE; i++)
  85                 if (mask->bits[i])
  86                         return 0;
  87         return 1;
  88 }
  89
  90 MASK_INLINE int snd_mask_full(const snd_mask_t *mask)
  91 {
  92         int i;
  93         for (i = 0; i < MASK_SIZE; i++)
  94                 if (mask->bits[i] != 0xffffffff)
  95                         return 0;
  96         return 1;
  97 }
  98
  99 MASK_INLINE unsigned int snd_mask_count(const snd_mask_t *mask)
 100 {
 101         int i, w = 0;
 102         for (i = 0; i < MASK_SIZE; i++)
 103                 w += hweight32(mask->bits[i]);
 104         return w;
 105 }
 106
 107 MASK_INLINE unsigned int snd_mask_min(const snd_mask_t *mask)
 108 {
 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);
 114         }
 115         return 0;
 116 }
 117
 118 MASK_INLINE unsigned int snd_mask_max(const snd_mask_t *mask)
 119 {
 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);
 125         }
 126         return 0;
 127 }
 128
 129 MASK_INLINE void snd_mask_set(snd_mask_t *mask, unsigned int val)
 130 {
 131         assert(val <= SND_MASK_MAX);
 132         mask->bits[MASK_OFS(val)] |= MASK_BIT(val);
 133 }
 134
 135 MASK_INLINE void snd_mask_reset(snd_mask_t *mask, unsigned int val)
 136 {
 137         assert(val <= SND_MASK_MAX);
 138         mask->bits[MASK_OFS(val)] &= ~MASK_BIT(val);
 139 }
 140
 141 MASK_INLINE void snd_mask_set_range(snd_mask_t *mask, unsigned int from, unsigned int to)
 142 {
 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);
 147 }
 148
 149 MASK_INLINE void snd_mask_reset_range(snd_mask_t *mask, unsigned int from, unsigned int to)
 150 {
 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);
 155 }
 156
 157 MASK_INLINE void snd_mask_leave(snd_mask_t *mask, unsigned int val)
 158 {
 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;
 164 }
 165
 166 MASK_INLINE void snd_mask_intersect(snd_mask_t *mask, const snd_mask_t *v)
 167 {
 168         int i;
 169         for (i = 0; i < MASK_SIZE; i++)
 170                 mask->bits[i] &= v->bits[i];
 171 }
 172
 173 MASK_INLINE void snd_mask_union(snd_mask_t *mask, const snd_mask_t *v)
 174 {
 175         int i;
 176         for (i = 0; i < MASK_SIZE; i++)
 177                 mask->bits[i] |= v->bits[i];
 178 }
 179
 180 MASK_INLINE int snd_mask_eq(const snd_mask_t *mask, const snd_mask_t *v)
 181 {
 182         return ! memcmp(mask, v, MASK_SIZE * 4);
 183 }
 184
 185 MASK_INLINE void snd_mask_copy(snd_mask_t *mask, const snd_mask_t *v)
 186 {
 187         *mask = *v;
 188 }
 189
 190 MASK_INLINE int snd_mask_test(const snd_mask_t *mask, unsigned int val)
 191 {
 192         assert(val <= SND_MASK_MAX);
 193         return mask->bits[MASK_OFS(val)] & MASK_BIT(val);
 194 }
 195
 196 MASK_INLINE int snd_mask_single(const snd_mask_t *mask)
 197 {
 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++;
 208         }
 209         return 1;
 210 }
 211
 212 MASK_INLINE int snd_mask_refine(snd_mask_t *mask, const snd_mask_t *v)
 213 {
 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);
 222 }
 223
 224 MASK_INLINE int snd_mask_refine_first(snd_mask_t *mask)
 225 {
 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;
 232 }
 233
 234 MASK_INLINE int snd_mask_refine_last(snd_mask_t *mask)
 235 {
 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;
 242 }
 243
 244 MASK_INLINE int snd_mask_refine_min(snd_mask_t *mask, unsigned int val)
 245 {
 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;
 254 }
 255
 256 MASK_INLINE int snd_mask_refine_max(snd_mask_t *mask, unsigned int val)
 257 {
 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;
 266 }
 267
 268 MASK_INLINE int snd_mask_refine_set(snd_mask_t *mask, unsigned int val)
 269 {
 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;
 278 }
 279
 280 MASK_INLINE int snd_mask_value(const snd_mask_t *mask)
 281 {
 282         assert(!snd_mask_empty(mask));
 283         return snd_mask_min(mask);
 284 }
 285
 286 MASK_INLINE int snd_mask_always_eq(const snd_mask_t *m1, const snd_mask_t *m2)
 287 {
 288         return snd_mask_single(m1) && snd_mask_single(m2) &&
 289                 snd_mask_value(m1) == snd_mask_value(m2);
 290 }
 291
 292 MASK_INLINE int snd_mask_never_eq(const snd_mask_t *m1, const snd_mask_t *m2)
 293 {
 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;
 299 }