include/sound/pcm_params.h

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 #ifndef __SOUND_PCM_PARAMS_H
   3 #define __SOUND_PCM_PARAMS_H
   4
   5 /*
   6  *  PCM params helpers
   7  *  Copyright (c) by Abramo Bagnara <abramo@alsa-project.org>
   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      /* we use so far 64bits only */
  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 /* Most of drivers need only this one */
  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 /* Most of drivers need only this one */
 137 static inline int snd_mask_test_format(const struct snd_mask *mask,
 138                                        snd_pcm_format_t format)
 139 {
 140         return snd_mask_test(mask, (__force unsigned int)format);
 141 }
 142
 143 static inline int snd_mask_single(const struct snd_mask *mask)
 144 {
 145         int i, c = 0;
 146         for (i = 0; i < SNDRV_MASK_SIZE; i++) {
 147                 if (! mask->bits[i])
 148                         continue;
 149                 if (mask->bits[i] & (mask->bits[i] - 1))
 150                         return 0;
 151                 if (c)
 152                         return 0;
 153                 c++;
 154         }
 155         return 1;
 156 }
 157
 158 static inline int snd_mask_refine(struct snd_mask *mask,
 159                                   const struct snd_mask *v)
 160 {
 161         struct snd_mask old;
 162         snd_mask_copy(&old, mask);
 163         snd_mask_intersect(mask, v);
 164         if (snd_mask_empty(mask))
 165                 return -EINVAL;
 166         return !snd_mask_eq(mask, &old);
 167 }
 168
 169 static inline int snd_mask_refine_first(struct snd_mask *mask)
 170 {
 171         if (snd_mask_single(mask))
 172                 return 0;
 173         snd_mask_leave(mask, snd_mask_min(mask));
 174         return 1;
 175 }
 176
 177 static inline int snd_mask_refine_last(struct snd_mask *mask)
 178 {
 179         if (snd_mask_single(mask))
 180                 return 0;
 181         snd_mask_leave(mask, snd_mask_max(mask));
 182         return 1;
 183 }
 184
 185 static inline int snd_mask_refine_min(struct snd_mask *mask, unsigned int val)
 186 {
 187         if (snd_mask_min(mask) >= val)
 188                 return 0;
 189         snd_mask_reset_range(mask, 0, val - 1);
 190         if (snd_mask_empty(mask))
 191                 return -EINVAL;
 192         return 1;
 193 }
 194
 195 static inline int snd_mask_refine_max(struct snd_mask *mask, unsigned int val)
 196 {
 197         if (snd_mask_max(mask) <= val)
 198                 return 0;
 199         snd_mask_reset_range(mask, val + 1, SNDRV_MASK_BITS);
 200         if (snd_mask_empty(mask))
 201                 return -EINVAL;
 202         return 1;
 203 }
 204
 205 static inline int snd_mask_refine_set(struct snd_mask *mask, unsigned int val)
 206 {
 207         int changed;
 208         changed = !snd_mask_single(mask);
 209         snd_mask_leave(mask, val);
 210         if (snd_mask_empty(mask))
 211                 return -EINVAL;
 212         return changed;
 213 }
 214
 215 static inline int snd_mask_value(const struct snd_mask *mask)
 216 {
 217         return snd_mask_min(mask);
 218 }
 219
 220 static inline void snd_interval_any(struct snd_interval *i)
 221 {
 222         i->min = 0;
 223         i->openmin = 0;
 224         i->max = UINT_MAX;
 225         i->openmax = 0;
 226         i->integer = 0;
 227         i->empty = 0;
 228 }
 229
 230 static inline void snd_interval_none(struct snd_interval *i)
 231 {
 232         i->empty = 1;
 233 }
 234
 235 static inline int snd_interval_checkempty(const struct snd_interval *i)
 236 {
 237         return (i->min > i->max ||
 238                 (i->min == i->max && (i->openmin || i->openmax)));
 239 }
 240
 241 static inline int snd_interval_empty(const struct snd_interval *i)
 242 {
 243         return i->empty;
 244 }
 245
 246 static inline int snd_interval_single(const struct snd_interval *i)
 247 {
 248         return (i->min == i->max ||
 249                 (i->min + 1 == i->max && (i->openmin || i->openmax)));
 250 }
 251
 252 static inline int snd_interval_value(const struct snd_interval *i)
 253 {
 254         if (i->openmin && !i->openmax)
 255                 return i->max;
 256         return i->min;
 257 }
 258
 259 static inline int snd_interval_min(const struct snd_interval *i)
 260 {
 261         return i->min;
 262 }
 263
 264 static inline int snd_interval_max(const struct snd_interval *i)
 265 {
 266         unsigned int v;
 267         v = i->max;
 268         if (i->openmax)
 269                 v--;
 270         return v;
 271 }
 272
 273 static inline int snd_interval_test(const struct snd_interval *i, unsigned int val)
 274 {
 275         return !((i->min > val || (i->min == val && i->openmin) ||
 276                   i->max < val || (i->max == val && i->openmax)));
 277 }
 278
 279 static inline void snd_interval_copy(struct snd_interval *d, const struct snd_interval *s)
 280 {
 281         *d = *s;
 282 }
 283
 284 static inline int snd_interval_setinteger(struct snd_interval *i)
 285 {
 286         if (i->integer)
 287                 return 0;
 288         if (i->openmin && i->openmax && i->min == i->max)
 289                 return -EINVAL;
 290         i->integer = 1;
 291         return 1;
 292 }
 293
 294 static inline int snd_interval_eq(const struct snd_interval *i1, const struct snd_interval *i2)
 295 {
 296         if (i1->empty)
 297                 return i2->empty;
 298         if (i2->empty)
 299                 return i1->empty;
 300         return i1->min == i2->min && i1->openmin == i2->openmin &&
 301                 i1->max == i2->max && i1->openmax == i2->openmax;
 302 }
 303
 304 /**
 305  * params_access - get the access type from the hw params
 306  * @p: hw params
 307  */
 308 static inline snd_pcm_access_t params_access(const struct snd_pcm_hw_params *p)
 309 {
 310         return (__force snd_pcm_access_t)snd_mask_min(hw_param_mask_c(p,
 311                 SNDRV_PCM_HW_PARAM_ACCESS));
 312 }
 313
 314 /**
 315  * params_format - get the sample format from the hw params
 316  * @p: hw params
 317  */
 318 static inline snd_pcm_format_t params_format(const struct snd_pcm_hw_params *p)
 319 {
 320         return (__force snd_pcm_format_t)snd_mask_min(hw_param_mask_c(p,
 321                 SNDRV_PCM_HW_PARAM_FORMAT));
 322 }
 323
 324 /**
 325  * params_subformat - get the sample subformat from the hw params
 326  * @p: hw params
 327  */
 328 static inline snd_pcm_subformat_t
 329 params_subformat(const struct snd_pcm_hw_params *p)
 330 {
 331         return (__force snd_pcm_subformat_t)snd_mask_min(hw_param_mask_c(p,
 332                 SNDRV_PCM_HW_PARAM_SUBFORMAT));
 333 }
 334
 335 /**
 336  * params_period_bytes - get the period size (in bytes) from the hw params
 337  * @p: hw params
 338  */
 339 static inline unsigned int
 340 params_period_bytes(const struct snd_pcm_hw_params *p)
 341 {
 342         return hw_param_interval_c(p, SNDRV_PCM_HW_PARAM_PERIOD_BYTES)->min;
 343 }
 344
 345 /**
 346  * params_width - get the number of bits of the sample format from the hw params
 347  * @p: hw params
 348  *
 349  * This function returns the number of bits per sample that the selected sample
 350  * format of the hw params has.
 351  */
 352 static inline int params_width(const struct snd_pcm_hw_params *p)
 353 {
 354         return snd_pcm_format_width(params_format(p));
 355 }
 356
 357 /*
 358  * params_physical_width - get the storage size of the sample format from the hw params
 359  * @p: hw params
 360  *
 361  * This functions returns the number of bits per sample that the selected sample
 362  * format of the hw params takes up in memory. This will be equal or larger than
 363  * params_width().
 364  */
 365 static inline int params_physical_width(const struct snd_pcm_hw_params *p)
 366 {
 367         return snd_pcm_format_physical_width(params_format(p));
 368 }
 369
 370 static inline void
 371 params_set_format(struct snd_pcm_hw_params *p, snd_pcm_format_t fmt)
 372 {
 373         snd_mask_set_format(hw_param_mask(p, SNDRV_PCM_HW_PARAM_FORMAT), fmt);
 374 }
 375
 376 #endif /* __SOUND_PCM_PARAMS_H */