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