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