xref: /openbmc/linux/sound/core/pcm_misc.c (revision 4800cd83)
1 /*
2  *  PCM Interface - misc routines
3  *  Copyright (c) 1998 by Jaroslav Kysela <perex@perex.cz>
4  *
5  *
6  *   This library is free software; you can redistribute it and/or modify
7  *   it under the terms of the GNU Library General Public License as
8  *   published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
15  *
16  *   You should have received a copy of the GNU Library 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 <linux/time.h>
23 #include <sound/core.h>
24 #include <sound/pcm.h>
25 #define SND_PCM_FORMAT_UNKNOWN (-1)
26 
27 /* NOTE: "signed" prefix must be given below since the default char is
28  *       unsigned on some architectures!
29  */
30 struct pcm_format_data {
31 	unsigned char width;	/* bit width */
32 	unsigned char phys;	/* physical bit width */
33 	signed char le;	/* 0 = big-endian, 1 = little-endian, -1 = others */
34 	signed char signd;	/* 0 = unsigned, 1 = signed, -1 = others */
35 	unsigned char silence[8];	/* silence data to fill */
36 };
37 
38 static struct pcm_format_data pcm_formats[SNDRV_PCM_FORMAT_LAST+1] = {
39 	[SNDRV_PCM_FORMAT_S8] = {
40 		.width = 8, .phys = 8, .le = -1, .signd = 1,
41 		.silence = {},
42 	},
43 	[SNDRV_PCM_FORMAT_U8] = {
44 		.width = 8, .phys = 8, .le = -1, .signd = 0,
45 		.silence = { 0x80 },
46 	},
47 	[SNDRV_PCM_FORMAT_S16_LE] = {
48 		.width = 16, .phys = 16, .le = 1, .signd = 1,
49 		.silence = {},
50 	},
51 	[SNDRV_PCM_FORMAT_S16_BE] = {
52 		.width = 16, .phys = 16, .le = 0, .signd = 1,
53 		.silence = {},
54 	},
55 	[SNDRV_PCM_FORMAT_U16_LE] = {
56 		.width = 16, .phys = 16, .le = 1, .signd = 0,
57 		.silence = { 0x00, 0x80 },
58 	},
59 	[SNDRV_PCM_FORMAT_U16_BE] = {
60 		.width = 16, .phys = 16, .le = 0, .signd = 0,
61 		.silence = { 0x80, 0x00 },
62 	},
63 	[SNDRV_PCM_FORMAT_S24_LE] = {
64 		.width = 24, .phys = 32, .le = 1, .signd = 1,
65 		.silence = {},
66 	},
67 	[SNDRV_PCM_FORMAT_S24_BE] = {
68 		.width = 24, .phys = 32, .le = 0, .signd = 1,
69 		.silence = {},
70 	},
71 	[SNDRV_PCM_FORMAT_U24_LE] = {
72 		.width = 24, .phys = 32, .le = 1, .signd = 0,
73 		.silence = { 0x00, 0x00, 0x80 },
74 	},
75 	[SNDRV_PCM_FORMAT_U24_BE] = {
76 		.width = 24, .phys = 32, .le = 0, .signd = 0,
77 		.silence = { 0x00, 0x80, 0x00, 0x00 },
78 	},
79 	[SNDRV_PCM_FORMAT_S32_LE] = {
80 		.width = 32, .phys = 32, .le = 1, .signd = 1,
81 		.silence = {},
82 	},
83 	[SNDRV_PCM_FORMAT_S32_BE] = {
84 		.width = 32, .phys = 32, .le = 0, .signd = 1,
85 		.silence = {},
86 	},
87 	[SNDRV_PCM_FORMAT_U32_LE] = {
88 		.width = 32, .phys = 32, .le = 1, .signd = 0,
89 		.silence = { 0x00, 0x00, 0x00, 0x80 },
90 	},
91 	[SNDRV_PCM_FORMAT_U32_BE] = {
92 		.width = 32, .phys = 32, .le = 0, .signd = 0,
93 		.silence = { 0x80, 0x00, 0x00, 0x00 },
94 	},
95 	[SNDRV_PCM_FORMAT_FLOAT_LE] = {
96 		.width = 32, .phys = 32, .le = 1, .signd = -1,
97 		.silence = {},
98 	},
99 	[SNDRV_PCM_FORMAT_FLOAT_BE] = {
100 		.width = 32, .phys = 32, .le = 0, .signd = -1,
101 		.silence = {},
102 	},
103 	[SNDRV_PCM_FORMAT_FLOAT64_LE] = {
104 		.width = 64, .phys = 64, .le = 1, .signd = -1,
105 		.silence = {},
106 	},
107 	[SNDRV_PCM_FORMAT_FLOAT64_BE] = {
108 		.width = 64, .phys = 64, .le = 0, .signd = -1,
109 		.silence = {},
110 	},
111 	[SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE] = {
112 		.width = 32, .phys = 32, .le = 1, .signd = -1,
113 		.silence = {},
114 	},
115 	[SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE] = {
116 		.width = 32, .phys = 32, .le = 0, .signd = -1,
117 		.silence = {},
118 	},
119 	[SNDRV_PCM_FORMAT_MU_LAW] = {
120 		.width = 8, .phys = 8, .le = -1, .signd = -1,
121 		.silence = { 0x7f },
122 	},
123 	[SNDRV_PCM_FORMAT_A_LAW] = {
124 		.width = 8, .phys = 8, .le = -1, .signd = -1,
125 		.silence = { 0x55 },
126 	},
127 	[SNDRV_PCM_FORMAT_IMA_ADPCM] = {
128 		.width = 4, .phys = 4, .le = -1, .signd = -1,
129 		.silence = {},
130 	},
131 	[SNDRV_PCM_FORMAT_G723_24] = {
132 		.width = 3, .phys = 3, .le = -1, .signd = -1,
133 		.silence = {},
134 	},
135 	[SNDRV_PCM_FORMAT_G723_40] = {
136 		.width = 5, .phys = 5, .le = -1, .signd = -1,
137 		.silence = {},
138 	},
139 	/* FIXME: the following three formats are not defined properly yet */
140 	[SNDRV_PCM_FORMAT_MPEG] = {
141 		.le = -1, .signd = -1,
142 	},
143 	[SNDRV_PCM_FORMAT_GSM] = {
144 		.le = -1, .signd = -1,
145 	},
146 	[SNDRV_PCM_FORMAT_SPECIAL] = {
147 		.le = -1, .signd = -1,
148 	},
149 	[SNDRV_PCM_FORMAT_S24_3LE] = {
150 		.width = 24, .phys = 24, .le = 1, .signd = 1,
151 		.silence = {},
152 	},
153 	[SNDRV_PCM_FORMAT_S24_3BE] = {
154 		.width = 24, .phys = 24, .le = 0, .signd = 1,
155 		.silence = {},
156 	},
157 	[SNDRV_PCM_FORMAT_U24_3LE] = {
158 		.width = 24, .phys = 24, .le = 1, .signd = 0,
159 		.silence = { 0x00, 0x00, 0x80 },
160 	},
161 	[SNDRV_PCM_FORMAT_U24_3BE] = {
162 		.width = 24, .phys = 24, .le = 0, .signd = 0,
163 		.silence = { 0x80, 0x00, 0x00 },
164 	},
165 	[SNDRV_PCM_FORMAT_S20_3LE] = {
166 		.width = 20, .phys = 24, .le = 1, .signd = 1,
167 		.silence = {},
168 	},
169 	[SNDRV_PCM_FORMAT_S20_3BE] = {
170 		.width = 20, .phys = 24, .le = 0, .signd = 1,
171 		.silence = {},
172 	},
173 	[SNDRV_PCM_FORMAT_U20_3LE] = {
174 		.width = 20, .phys = 24, .le = 1, .signd = 0,
175 		.silence = { 0x00, 0x00, 0x08 },
176 	},
177 	[SNDRV_PCM_FORMAT_U20_3BE] = {
178 		.width = 20, .phys = 24, .le = 0, .signd = 0,
179 		.silence = { 0x08, 0x00, 0x00 },
180 	},
181 	[SNDRV_PCM_FORMAT_S18_3LE] = {
182 		.width = 18, .phys = 24, .le = 1, .signd = 1,
183 		.silence = {},
184 	},
185 	[SNDRV_PCM_FORMAT_S18_3BE] = {
186 		.width = 18, .phys = 24, .le = 0, .signd = 1,
187 		.silence = {},
188 	},
189 	[SNDRV_PCM_FORMAT_U18_3LE] = {
190 		.width = 18, .phys = 24, .le = 1, .signd = 0,
191 		.silence = { 0x00, 0x00, 0x02 },
192 	},
193 	[SNDRV_PCM_FORMAT_U18_3BE] = {
194 		.width = 18, .phys = 24, .le = 0, .signd = 0,
195 		.silence = { 0x02, 0x00, 0x00 },
196 	},
197 	[SNDRV_PCM_FORMAT_G723_24_1B] = {
198 		.width = 3, .phys = 8, .le = -1, .signd = -1,
199 		.silence = {},
200 	},
201 	[SNDRV_PCM_FORMAT_G723_40_1B] = {
202 		.width = 5, .phys = 8, .le = -1, .signd = -1,
203 		.silence = {},
204 	},
205 };
206 
207 
208 /**
209  * snd_pcm_format_signed - Check the PCM format is signed linear
210  * @format: the format to check
211  *
212  * Returns 1 if the given PCM format is signed linear, 0 if unsigned
213  * linear, and a negative error code for non-linear formats.
214  */
215 int snd_pcm_format_signed(snd_pcm_format_t format)
216 {
217 	int val;
218 	if (format < 0 || format > SNDRV_PCM_FORMAT_LAST)
219 		return -EINVAL;
220 	if ((val = pcm_formats[format].signd) < 0)
221 		return -EINVAL;
222 	return val;
223 }
224 
225 EXPORT_SYMBOL(snd_pcm_format_signed);
226 
227 /**
228  * snd_pcm_format_unsigned - Check the PCM format is unsigned linear
229  * @format: the format to check
230  *
231  * Returns 1 if the given PCM format is unsigned linear, 0 if signed
232  * linear, and a negative error code for non-linear formats.
233  */
234 int snd_pcm_format_unsigned(snd_pcm_format_t format)
235 {
236 	int val;
237 
238 	val = snd_pcm_format_signed(format);
239 	if (val < 0)
240 		return val;
241 	return !val;
242 }
243 
244 EXPORT_SYMBOL(snd_pcm_format_unsigned);
245 
246 /**
247  * snd_pcm_format_linear - Check the PCM format is linear
248  * @format: the format to check
249  *
250  * Returns 1 if the given PCM format is linear, 0 if not.
251  */
252 int snd_pcm_format_linear(snd_pcm_format_t format)
253 {
254 	return snd_pcm_format_signed(format) >= 0;
255 }
256 
257 EXPORT_SYMBOL(snd_pcm_format_linear);
258 
259 /**
260  * snd_pcm_format_little_endian - Check the PCM format is little-endian
261  * @format: the format to check
262  *
263  * Returns 1 if the given PCM format is little-endian, 0 if
264  * big-endian, or a negative error code if endian not specified.
265  */
266 int snd_pcm_format_little_endian(snd_pcm_format_t format)
267 {
268 	int val;
269 	if (format < 0 || format > SNDRV_PCM_FORMAT_LAST)
270 		return -EINVAL;
271 	if ((val = pcm_formats[format].le) < 0)
272 		return -EINVAL;
273 	return val;
274 }
275 
276 EXPORT_SYMBOL(snd_pcm_format_little_endian);
277 
278 /**
279  * snd_pcm_format_big_endian - Check the PCM format is big-endian
280  * @format: the format to check
281  *
282  * Returns 1 if the given PCM format is big-endian, 0 if
283  * little-endian, or a negative error code if endian not specified.
284  */
285 int snd_pcm_format_big_endian(snd_pcm_format_t format)
286 {
287 	int val;
288 
289 	val = snd_pcm_format_little_endian(format);
290 	if (val < 0)
291 		return val;
292 	return !val;
293 }
294 
295 EXPORT_SYMBOL(snd_pcm_format_big_endian);
296 
297 /**
298  * snd_pcm_format_width - return the bit-width of the format
299  * @format: the format to check
300  *
301  * Returns the bit-width of the format, or a negative error code
302  * if unknown format.
303  */
304 int snd_pcm_format_width(snd_pcm_format_t format)
305 {
306 	int val;
307 	if (format < 0 || format > SNDRV_PCM_FORMAT_LAST)
308 		return -EINVAL;
309 	if ((val = pcm_formats[format].width) == 0)
310 		return -EINVAL;
311 	return val;
312 }
313 
314 EXPORT_SYMBOL(snd_pcm_format_width);
315 
316 /**
317  * snd_pcm_format_physical_width - return the physical bit-width of the format
318  * @format: the format to check
319  *
320  * Returns the physical bit-width of the format, or a negative error code
321  * if unknown format.
322  */
323 int snd_pcm_format_physical_width(snd_pcm_format_t format)
324 {
325 	int val;
326 	if (format < 0 || format > SNDRV_PCM_FORMAT_LAST)
327 		return -EINVAL;
328 	if ((val = pcm_formats[format].phys) == 0)
329 		return -EINVAL;
330 	return val;
331 }
332 
333 EXPORT_SYMBOL(snd_pcm_format_physical_width);
334 
335 /**
336  * snd_pcm_format_size - return the byte size of samples on the given format
337  * @format: the format to check
338  * @samples: sampling rate
339  *
340  * Returns the byte size of the given samples for the format, or a
341  * negative error code if unknown format.
342  */
343 ssize_t snd_pcm_format_size(snd_pcm_format_t format, size_t samples)
344 {
345 	int phys_width = snd_pcm_format_physical_width(format);
346 	if (phys_width < 0)
347 		return -EINVAL;
348 	return samples * phys_width / 8;
349 }
350 
351 EXPORT_SYMBOL(snd_pcm_format_size);
352 
353 /**
354  * snd_pcm_format_silence_64 - return the silent data in 8 bytes array
355  * @format: the format to check
356  *
357  * Returns the format pattern to fill or NULL if error.
358  */
359 const unsigned char *snd_pcm_format_silence_64(snd_pcm_format_t format)
360 {
361 	if (format < 0 || format > SNDRV_PCM_FORMAT_LAST)
362 		return NULL;
363 	if (! pcm_formats[format].phys)
364 		return NULL;
365 	return pcm_formats[format].silence;
366 }
367 
368 EXPORT_SYMBOL(snd_pcm_format_silence_64);
369 
370 /**
371  * snd_pcm_format_set_silence - set the silence data on the buffer
372  * @format: the PCM format
373  * @data: the buffer pointer
374  * @samples: the number of samples to set silence
375  *
376  * Sets the silence data on the buffer for the given samples.
377  *
378  * Returns zero if successful, or a negative error code on failure.
379  */
380 int snd_pcm_format_set_silence(snd_pcm_format_t format, void *data, unsigned int samples)
381 {
382 	int width;
383 	unsigned char *dst, *pat;
384 
385 	if (format < 0 || format > SNDRV_PCM_FORMAT_LAST)
386 		return -EINVAL;
387 	if (samples == 0)
388 		return 0;
389 	width = pcm_formats[format].phys; /* physical width */
390 	pat = pcm_formats[format].silence;
391 	if (! width)
392 		return -EINVAL;
393 	/* signed or 1 byte data */
394 	if (pcm_formats[format].signd == 1 || width <= 8) {
395 		unsigned int bytes = samples * width / 8;
396 		memset(data, *pat, bytes);
397 		return 0;
398 	}
399 	/* non-zero samples, fill using a loop */
400 	width /= 8;
401 	dst = data;
402 #if 0
403 	while (samples--) {
404 		memcpy(dst, pat, width);
405 		dst += width;
406 	}
407 #else
408 	/* a bit optimization for constant width */
409 	switch (width) {
410 	case 2:
411 		while (samples--) {
412 			memcpy(dst, pat, 2);
413 			dst += 2;
414 		}
415 		break;
416 	case 3:
417 		while (samples--) {
418 			memcpy(dst, pat, 3);
419 			dst += 3;
420 		}
421 		break;
422 	case 4:
423 		while (samples--) {
424 			memcpy(dst, pat, 4);
425 			dst += 4;
426 		}
427 		break;
428 	case 8:
429 		while (samples--) {
430 			memcpy(dst, pat, 8);
431 			dst += 8;
432 		}
433 		break;
434 	}
435 #endif
436 	return 0;
437 }
438 
439 EXPORT_SYMBOL(snd_pcm_format_set_silence);
440 
441 /**
442  * snd_pcm_limit_hw_rates - determine rate_min/rate_max fields
443  * @runtime: the runtime instance
444  *
445  * Determines the rate_min and rate_max fields from the rates bits of
446  * the given runtime->hw.
447  *
448  * Returns zero if successful.
449  */
450 int snd_pcm_limit_hw_rates(struct snd_pcm_runtime *runtime)
451 {
452 	int i;
453 	for (i = 0; i < (int)snd_pcm_known_rates.count; i++) {
454 		if (runtime->hw.rates & (1 << i)) {
455 			runtime->hw.rate_min = snd_pcm_known_rates.list[i];
456 			break;
457 		}
458 	}
459 	for (i = (int)snd_pcm_known_rates.count - 1; i >= 0; i--) {
460 		if (runtime->hw.rates & (1 << i)) {
461 			runtime->hw.rate_max = snd_pcm_known_rates.list[i];
462 			break;
463 		}
464 	}
465 	return 0;
466 }
467 
468 EXPORT_SYMBOL(snd_pcm_limit_hw_rates);
469 
470 /**
471  * snd_pcm_rate_to_rate_bit - converts sample rate to SNDRV_PCM_RATE_xxx bit
472  * @rate: the sample rate to convert
473  *
474  * Returns the SNDRV_PCM_RATE_xxx flag that corresponds to the given rate, or
475  * SNDRV_PCM_RATE_KNOT for an unknown rate.
476  */
477 unsigned int snd_pcm_rate_to_rate_bit(unsigned int rate)
478 {
479 	unsigned int i;
480 
481 	for (i = 0; i < snd_pcm_known_rates.count; i++)
482 		if (snd_pcm_known_rates.list[i] == rate)
483 			return 1u << i;
484 	return SNDRV_PCM_RATE_KNOT;
485 }
486 EXPORT_SYMBOL(snd_pcm_rate_to_rate_bit);
487