Linux Audio

Check our new training course

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