xref: /linux/sound/core/pcm_misc.c (revision 37744feebc086908fd89760650f458ab19071750)
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 <linux/export.h>
24 #include <sound/core.h>
25 #include <sound/pcm.h>
26 
27 #include "pcm_local.h"
28 
29 #define SND_PCM_FORMAT_UNKNOWN (-1)
30 
31 /* NOTE: "signed" prefix must be given below since the default char is
32  *       unsigned on some architectures!
33  */
34 struct pcm_format_data {
35 	unsigned char width;	/* bit width */
36 	unsigned char phys;	/* physical bit width */
37 	signed char le;	/* 0 = big-endian, 1 = little-endian, -1 = others */
38 	signed char signd;	/* 0 = unsigned, 1 = signed, -1 = others */
39 	unsigned char silence[8];	/* silence data to fill */
40 };
41 
42 /* we do lots of calculations on snd_pcm_format_t; shut up sparse */
43 #define INT	__force int
44 
45 static bool valid_format(snd_pcm_format_t format)
46 {
47 	return (INT)format >= 0 && (INT)format <= (INT)SNDRV_PCM_FORMAT_LAST;
48 }
49 
50 static const struct pcm_format_data pcm_formats[(INT)SNDRV_PCM_FORMAT_LAST+1] = {
51 	[SNDRV_PCM_FORMAT_S8] = {
52 		.width = 8, .phys = 8, .le = -1, .signd = 1,
53 		.silence = {},
54 	},
55 	[SNDRV_PCM_FORMAT_U8] = {
56 		.width = 8, .phys = 8, .le = -1, .signd = 0,
57 		.silence = { 0x80 },
58 	},
59 	[SNDRV_PCM_FORMAT_S16_LE] = {
60 		.width = 16, .phys = 16, .le = 1, .signd = 1,
61 		.silence = {},
62 	},
63 	[SNDRV_PCM_FORMAT_S16_BE] = {
64 		.width = 16, .phys = 16, .le = 0, .signd = 1,
65 		.silence = {},
66 	},
67 	[SNDRV_PCM_FORMAT_U16_LE] = {
68 		.width = 16, .phys = 16, .le = 1, .signd = 0,
69 		.silence = { 0x00, 0x80 },
70 	},
71 	[SNDRV_PCM_FORMAT_U16_BE] = {
72 		.width = 16, .phys = 16, .le = 0, .signd = 0,
73 		.silence = { 0x80, 0x00 },
74 	},
75 	[SNDRV_PCM_FORMAT_S24_LE] = {
76 		.width = 24, .phys = 32, .le = 1, .signd = 1,
77 		.silence = {},
78 	},
79 	[SNDRV_PCM_FORMAT_S24_BE] = {
80 		.width = 24, .phys = 32, .le = 0, .signd = 1,
81 		.silence = {},
82 	},
83 	[SNDRV_PCM_FORMAT_U24_LE] = {
84 		.width = 24, .phys = 32, .le = 1, .signd = 0,
85 		.silence = { 0x00, 0x00, 0x80 },
86 	},
87 	[SNDRV_PCM_FORMAT_U24_BE] = {
88 		.width = 24, .phys = 32, .le = 0, .signd = 0,
89 		.silence = { 0x00, 0x80, 0x00, 0x00 },
90 	},
91 	[SNDRV_PCM_FORMAT_S32_LE] = {
92 		.width = 32, .phys = 32, .le = 1, .signd = 1,
93 		.silence = {},
94 	},
95 	[SNDRV_PCM_FORMAT_S32_BE] = {
96 		.width = 32, .phys = 32, .le = 0, .signd = 1,
97 		.silence = {},
98 	},
99 	[SNDRV_PCM_FORMAT_U32_LE] = {
100 		.width = 32, .phys = 32, .le = 1, .signd = 0,
101 		.silence = { 0x00, 0x00, 0x00, 0x80 },
102 	},
103 	[SNDRV_PCM_FORMAT_U32_BE] = {
104 		.width = 32, .phys = 32, .le = 0, .signd = 0,
105 		.silence = { 0x80, 0x00, 0x00, 0x00 },
106 	},
107 	[SNDRV_PCM_FORMAT_FLOAT_LE] = {
108 		.width = 32, .phys = 32, .le = 1, .signd = -1,
109 		.silence = {},
110 	},
111 	[SNDRV_PCM_FORMAT_FLOAT_BE] = {
112 		.width = 32, .phys = 32, .le = 0, .signd = -1,
113 		.silence = {},
114 	},
115 	[SNDRV_PCM_FORMAT_FLOAT64_LE] = {
116 		.width = 64, .phys = 64, .le = 1, .signd = -1,
117 		.silence = {},
118 	},
119 	[SNDRV_PCM_FORMAT_FLOAT64_BE] = {
120 		.width = 64, .phys = 64, .le = 0, .signd = -1,
121 		.silence = {},
122 	},
123 	[SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE] = {
124 		.width = 32, .phys = 32, .le = 1, .signd = -1,
125 		.silence = {},
126 	},
127 	[SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE] = {
128 		.width = 32, .phys = 32, .le = 0, .signd = -1,
129 		.silence = {},
130 	},
131 	[SNDRV_PCM_FORMAT_MU_LAW] = {
132 		.width = 8, .phys = 8, .le = -1, .signd = -1,
133 		.silence = { 0x7f },
134 	},
135 	[SNDRV_PCM_FORMAT_A_LAW] = {
136 		.width = 8, .phys = 8, .le = -1, .signd = -1,
137 		.silence = { 0x55 },
138 	},
139 	[SNDRV_PCM_FORMAT_IMA_ADPCM] = {
140 		.width = 4, .phys = 4, .le = -1, .signd = -1,
141 		.silence = {},
142 	},
143 	[SNDRV_PCM_FORMAT_G723_24] = {
144 		.width = 3, .phys = 3, .le = -1, .signd = -1,
145 		.silence = {},
146 	},
147 	[SNDRV_PCM_FORMAT_G723_40] = {
148 		.width = 5, .phys = 5, .le = -1, .signd = -1,
149 		.silence = {},
150 	},
151 	[SNDRV_PCM_FORMAT_DSD_U8] = {
152 		.width = 8, .phys = 8, .le = 1, .signd = 0,
153 		.silence = { 0x69 },
154 	},
155 	[SNDRV_PCM_FORMAT_DSD_U16_LE] = {
156 		.width = 16, .phys = 16, .le = 1, .signd = 0,
157 		.silence = { 0x69, 0x69 },
158 	},
159 	[SNDRV_PCM_FORMAT_DSD_U32_LE] = {
160 		.width = 32, .phys = 32, .le = 1, .signd = 0,
161 		.silence = { 0x69, 0x69, 0x69, 0x69 },
162 	},
163 	[SNDRV_PCM_FORMAT_DSD_U16_BE] = {
164 		.width = 16, .phys = 16, .le = 0, .signd = 0,
165 		.silence = { 0x69, 0x69 },
166 	},
167 	[SNDRV_PCM_FORMAT_DSD_U32_BE] = {
168 		.width = 32, .phys = 32, .le = 0, .signd = 0,
169 		.silence = { 0x69, 0x69, 0x69, 0x69 },
170 	},
171 	/* FIXME: the following two formats are not defined properly yet */
172 	[SNDRV_PCM_FORMAT_MPEG] = {
173 		.le = -1, .signd = -1,
174 	},
175 	[SNDRV_PCM_FORMAT_GSM] = {
176 		.le = -1, .signd = -1,
177 	},
178 	[SNDRV_PCM_FORMAT_S20_LE] = {
179 		.width = 20, .phys = 32, .le = 1, .signd = 1,
180 		.silence = {},
181 	},
182 	[SNDRV_PCM_FORMAT_S20_BE] = {
183 		.width = 20, .phys = 32, .le = 0, .signd = 1,
184 		.silence = {},
185 	},
186 	[SNDRV_PCM_FORMAT_U20_LE] = {
187 		.width = 20, .phys = 32, .le = 1, .signd = 0,
188 		.silence = { 0x00, 0x00, 0x08, 0x00 },
189 	},
190 	[SNDRV_PCM_FORMAT_U20_BE] = {
191 		.width = 20, .phys = 32, .le = 0, .signd = 0,
192 		.silence = { 0x00, 0x08, 0x00, 0x00 },
193 	},
194 	/* FIXME: the following format is not defined properly yet */
195 	[SNDRV_PCM_FORMAT_SPECIAL] = {
196 		.le = -1, .signd = -1,
197 	},
198 	[SNDRV_PCM_FORMAT_S24_3LE] = {
199 		.width = 24, .phys = 24, .le = 1, .signd = 1,
200 		.silence = {},
201 	},
202 	[SNDRV_PCM_FORMAT_S24_3BE] = {
203 		.width = 24, .phys = 24, .le = 0, .signd = 1,
204 		.silence = {},
205 	},
206 	[SNDRV_PCM_FORMAT_U24_3LE] = {
207 		.width = 24, .phys = 24, .le = 1, .signd = 0,
208 		.silence = { 0x00, 0x00, 0x80 },
209 	},
210 	[SNDRV_PCM_FORMAT_U24_3BE] = {
211 		.width = 24, .phys = 24, .le = 0, .signd = 0,
212 		.silence = { 0x80, 0x00, 0x00 },
213 	},
214 	[SNDRV_PCM_FORMAT_S20_3LE] = {
215 		.width = 20, .phys = 24, .le = 1, .signd = 1,
216 		.silence = {},
217 	},
218 	[SNDRV_PCM_FORMAT_S20_3BE] = {
219 		.width = 20, .phys = 24, .le = 0, .signd = 1,
220 		.silence = {},
221 	},
222 	[SNDRV_PCM_FORMAT_U20_3LE] = {
223 		.width = 20, .phys = 24, .le = 1, .signd = 0,
224 		.silence = { 0x00, 0x00, 0x08 },
225 	},
226 	[SNDRV_PCM_FORMAT_U20_3BE] = {
227 		.width = 20, .phys = 24, .le = 0, .signd = 0,
228 		.silence = { 0x08, 0x00, 0x00 },
229 	},
230 	[SNDRV_PCM_FORMAT_S18_3LE] = {
231 		.width = 18, .phys = 24, .le = 1, .signd = 1,
232 		.silence = {},
233 	},
234 	[SNDRV_PCM_FORMAT_S18_3BE] = {
235 		.width = 18, .phys = 24, .le = 0, .signd = 1,
236 		.silence = {},
237 	},
238 	[SNDRV_PCM_FORMAT_U18_3LE] = {
239 		.width = 18, .phys = 24, .le = 1, .signd = 0,
240 		.silence = { 0x00, 0x00, 0x02 },
241 	},
242 	[SNDRV_PCM_FORMAT_U18_3BE] = {
243 		.width = 18, .phys = 24, .le = 0, .signd = 0,
244 		.silence = { 0x02, 0x00, 0x00 },
245 	},
246 	[SNDRV_PCM_FORMAT_G723_24_1B] = {
247 		.width = 3, .phys = 8, .le = -1, .signd = -1,
248 		.silence = {},
249 	},
250 	[SNDRV_PCM_FORMAT_G723_40_1B] = {
251 		.width = 5, .phys = 8, .le = -1, .signd = -1,
252 		.silence = {},
253 	},
254 };
255 
256 
257 /**
258  * snd_pcm_format_signed - Check the PCM format is signed linear
259  * @format: the format to check
260  *
261  * Return: 1 if the given PCM format is signed linear, 0 if unsigned
262  * linear, and a negative error code for non-linear formats.
263  */
264 int snd_pcm_format_signed(snd_pcm_format_t format)
265 {
266 	int val;
267 	if (!valid_format(format))
268 		return -EINVAL;
269 	if ((val = pcm_formats[(INT)format].signd) < 0)
270 		return -EINVAL;
271 	return val;
272 }
273 EXPORT_SYMBOL(snd_pcm_format_signed);
274 
275 /**
276  * snd_pcm_format_unsigned - Check the PCM format is unsigned linear
277  * @format: the format to check
278  *
279  * Return: 1 if the given PCM format is unsigned linear, 0 if signed
280  * linear, and a negative error code for non-linear formats.
281  */
282 int snd_pcm_format_unsigned(snd_pcm_format_t format)
283 {
284 	int val;
285 
286 	val = snd_pcm_format_signed(format);
287 	if (val < 0)
288 		return val;
289 	return !val;
290 }
291 EXPORT_SYMBOL(snd_pcm_format_unsigned);
292 
293 /**
294  * snd_pcm_format_linear - Check the PCM format is linear
295  * @format: the format to check
296  *
297  * Return: 1 if the given PCM format is linear, 0 if not.
298  */
299 int snd_pcm_format_linear(snd_pcm_format_t format)
300 {
301 	return snd_pcm_format_signed(format) >= 0;
302 }
303 EXPORT_SYMBOL(snd_pcm_format_linear);
304 
305 /**
306  * snd_pcm_format_little_endian - Check the PCM format is little-endian
307  * @format: the format to check
308  *
309  * Return: 1 if the given PCM format is little-endian, 0 if
310  * big-endian, or a negative error code if endian not specified.
311  */
312 int snd_pcm_format_little_endian(snd_pcm_format_t format)
313 {
314 	int val;
315 	if (!valid_format(format))
316 		return -EINVAL;
317 	if ((val = pcm_formats[(INT)format].le) < 0)
318 		return -EINVAL;
319 	return val;
320 }
321 EXPORT_SYMBOL(snd_pcm_format_little_endian);
322 
323 /**
324  * snd_pcm_format_big_endian - Check the PCM format is big-endian
325  * @format: the format to check
326  *
327  * Return: 1 if the given PCM format is big-endian, 0 if
328  * little-endian, or a negative error code if endian not specified.
329  */
330 int snd_pcm_format_big_endian(snd_pcm_format_t format)
331 {
332 	int val;
333 
334 	val = snd_pcm_format_little_endian(format);
335 	if (val < 0)
336 		return val;
337 	return !val;
338 }
339 EXPORT_SYMBOL(snd_pcm_format_big_endian);
340 
341 /**
342  * snd_pcm_format_width - return the bit-width of the format
343  * @format: the format to check
344  *
345  * Return: The bit-width of the format, or a negative error code
346  * if unknown format.
347  */
348 int snd_pcm_format_width(snd_pcm_format_t format)
349 {
350 	int val;
351 	if (!valid_format(format))
352 		return -EINVAL;
353 	if ((val = pcm_formats[(INT)format].width) == 0)
354 		return -EINVAL;
355 	return val;
356 }
357 EXPORT_SYMBOL(snd_pcm_format_width);
358 
359 /**
360  * snd_pcm_format_physical_width - return the physical bit-width of the format
361  * @format: the format to check
362  *
363  * Return: The physical bit-width of the format, or a negative error code
364  * if unknown format.
365  */
366 int snd_pcm_format_physical_width(snd_pcm_format_t format)
367 {
368 	int val;
369 	if (!valid_format(format))
370 		return -EINVAL;
371 	if ((val = pcm_formats[(INT)format].phys) == 0)
372 		return -EINVAL;
373 	return val;
374 }
375 EXPORT_SYMBOL(snd_pcm_format_physical_width);
376 
377 /**
378  * snd_pcm_format_size - return the byte size of samples on the given format
379  * @format: the format to check
380  * @samples: sampling rate
381  *
382  * Return: The byte size of the given samples for the format, or a
383  * negative error code if unknown format.
384  */
385 ssize_t snd_pcm_format_size(snd_pcm_format_t format, size_t samples)
386 {
387 	int phys_width = snd_pcm_format_physical_width(format);
388 	if (phys_width < 0)
389 		return -EINVAL;
390 	return samples * phys_width / 8;
391 }
392 EXPORT_SYMBOL(snd_pcm_format_size);
393 
394 /**
395  * snd_pcm_format_silence_64 - return the silent data in 8 bytes array
396  * @format: the format to check
397  *
398  * Return: The format pattern to fill or %NULL if error.
399  */
400 const unsigned char *snd_pcm_format_silence_64(snd_pcm_format_t format)
401 {
402 	if (!valid_format(format))
403 		return NULL;
404 	if (! pcm_formats[(INT)format].phys)
405 		return NULL;
406 	return pcm_formats[(INT)format].silence;
407 }
408 EXPORT_SYMBOL(snd_pcm_format_silence_64);
409 
410 /**
411  * snd_pcm_format_set_silence - set the silence data on the buffer
412  * @format: the PCM format
413  * @data: the buffer pointer
414  * @samples: the number of samples to set silence
415  *
416  * Sets the silence data on the buffer for the given samples.
417  *
418  * Return: Zero if successful, or a negative error code on failure.
419  */
420 int snd_pcm_format_set_silence(snd_pcm_format_t format, void *data, unsigned int samples)
421 {
422 	int width;
423 	unsigned char *dst;
424 	const unsigned char *pat;
425 
426 	if (!valid_format(format))
427 		return -EINVAL;
428 	if (samples == 0)
429 		return 0;
430 	width = pcm_formats[(INT)format].phys; /* physical width */
431 	pat = pcm_formats[(INT)format].silence;
432 	if (! width)
433 		return -EINVAL;
434 	/* signed or 1 byte data */
435 	if (pcm_formats[(INT)format].signd == 1 || width <= 8) {
436 		unsigned int bytes = samples * width / 8;
437 		memset(data, *pat, bytes);
438 		return 0;
439 	}
440 	/* non-zero samples, fill using a loop */
441 	width /= 8;
442 	dst = data;
443 #if 0
444 	while (samples--) {
445 		memcpy(dst, pat, width);
446 		dst += width;
447 	}
448 #else
449 	/* a bit optimization for constant width */
450 	switch (width) {
451 	case 2:
452 		while (samples--) {
453 			memcpy(dst, pat, 2);
454 			dst += 2;
455 		}
456 		break;
457 	case 3:
458 		while (samples--) {
459 			memcpy(dst, pat, 3);
460 			dst += 3;
461 		}
462 		break;
463 	case 4:
464 		while (samples--) {
465 			memcpy(dst, pat, 4);
466 			dst += 4;
467 		}
468 		break;
469 	case 8:
470 		while (samples--) {
471 			memcpy(dst, pat, 8);
472 			dst += 8;
473 		}
474 		break;
475 	}
476 #endif
477 	return 0;
478 }
479 EXPORT_SYMBOL(snd_pcm_format_set_silence);
480 
481 /**
482  * snd_pcm_hw_limit_rates - determine rate_min/rate_max fields
483  * @hw: the pcm hw instance
484  *
485  * Determines the rate_min and rate_max fields from the rates bits of
486  * the given hw.
487  *
488  * Return: Zero if successful.
489  */
490 int snd_pcm_hw_limit_rates(struct snd_pcm_hardware *hw)
491 {
492 	int i;
493 	for (i = 0; i < (int)snd_pcm_known_rates.count; i++) {
494 		if (hw->rates & (1 << i)) {
495 			hw->rate_min = snd_pcm_known_rates.list[i];
496 			break;
497 		}
498 	}
499 	for (i = (int)snd_pcm_known_rates.count - 1; i >= 0; i--) {
500 		if (hw->rates & (1 << i)) {
501 			hw->rate_max = snd_pcm_known_rates.list[i];
502 			break;
503 		}
504 	}
505 	return 0;
506 }
507 EXPORT_SYMBOL(snd_pcm_hw_limit_rates);
508 
509 /**
510  * snd_pcm_rate_to_rate_bit - converts sample rate to SNDRV_PCM_RATE_xxx bit
511  * @rate: the sample rate to convert
512  *
513  * Return: The SNDRV_PCM_RATE_xxx flag that corresponds to the given rate, or
514  * SNDRV_PCM_RATE_KNOT for an unknown rate.
515  */
516 unsigned int snd_pcm_rate_to_rate_bit(unsigned int rate)
517 {
518 	unsigned int i;
519 
520 	for (i = 0; i < snd_pcm_known_rates.count; i++)
521 		if (snd_pcm_known_rates.list[i] == rate)
522 			return 1u << i;
523 	return SNDRV_PCM_RATE_KNOT;
524 }
525 EXPORT_SYMBOL(snd_pcm_rate_to_rate_bit);
526 
527 /**
528  * snd_pcm_rate_bit_to_rate - converts SNDRV_PCM_RATE_xxx bit to sample rate
529  * @rate_bit: the rate bit to convert
530  *
531  * Return: The sample rate that corresponds to the given SNDRV_PCM_RATE_xxx flag
532  * or 0 for an unknown rate bit.
533  */
534 unsigned int snd_pcm_rate_bit_to_rate(unsigned int rate_bit)
535 {
536 	unsigned int i;
537 
538 	for (i = 0; i < snd_pcm_known_rates.count; i++)
539 		if ((1u << i) == rate_bit)
540 			return snd_pcm_known_rates.list[i];
541 	return 0;
542 }
543 EXPORT_SYMBOL(snd_pcm_rate_bit_to_rate);
544 
545 static unsigned int snd_pcm_rate_mask_sanitize(unsigned int rates)
546 {
547 	if (rates & SNDRV_PCM_RATE_CONTINUOUS)
548 		return SNDRV_PCM_RATE_CONTINUOUS;
549 	else if (rates & SNDRV_PCM_RATE_KNOT)
550 		return SNDRV_PCM_RATE_KNOT;
551 	return rates;
552 }
553 
554 /**
555  * snd_pcm_rate_mask_intersect - computes the intersection between two rate masks
556  * @rates_a: The first rate mask
557  * @rates_b: The second rate mask
558  *
559  * This function computes the rates that are supported by both rate masks passed
560  * to the function. It will take care of the special handling of
561  * SNDRV_PCM_RATE_CONTINUOUS and SNDRV_PCM_RATE_KNOT.
562  *
563  * Return: A rate mask containing the rates that are supported by both rates_a
564  * and rates_b.
565  */
566 unsigned int snd_pcm_rate_mask_intersect(unsigned int rates_a,
567 	unsigned int rates_b)
568 {
569 	rates_a = snd_pcm_rate_mask_sanitize(rates_a);
570 	rates_b = snd_pcm_rate_mask_sanitize(rates_b);
571 
572 	if (rates_a & SNDRV_PCM_RATE_CONTINUOUS)
573 		return rates_b;
574 	else if (rates_b & SNDRV_PCM_RATE_CONTINUOUS)
575 		return rates_a;
576 	else if (rates_a & SNDRV_PCM_RATE_KNOT)
577 		return rates_b;
578 	else if (rates_b & SNDRV_PCM_RATE_KNOT)
579 		return rates_a;
580 	return rates_a & rates_b;
581 }
582 EXPORT_SYMBOL_GPL(snd_pcm_rate_mask_intersect);
583 
584 /**
585  * snd_pcm_rate_range_to_bits - converts rate range to SNDRV_PCM_RATE_xxx bit
586  * @rate_min: the minimum sample rate
587  * @rate_max: the maximum sample rate
588  *
589  * This function has an implicit assumption: the rates in the given range have
590  * only the pre-defined rates like 44100 or 16000.
591  *
592  * Return: The SNDRV_PCM_RATE_xxx flag that corresponds to the given rate range,
593  * or SNDRV_PCM_RATE_KNOT for an unknown range.
594  */
595 unsigned int snd_pcm_rate_range_to_bits(unsigned int rate_min,
596 	unsigned int rate_max)
597 {
598 	unsigned int rates = 0;
599 	int i;
600 
601 	for (i = 0; i < snd_pcm_known_rates.count; i++) {
602 		if (snd_pcm_known_rates.list[i] >= rate_min
603 			&& snd_pcm_known_rates.list[i] <= rate_max)
604 			rates |= 1 << i;
605 	}
606 
607 	if (!rates)
608 		rates = SNDRV_PCM_RATE_KNOT;
609 
610 	return rates;
611 }
612 EXPORT_SYMBOL_GPL(snd_pcm_rate_range_to_bits);
613