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 */ 31 struct 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 42 static 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 */ 239 int 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 249 EXPORT_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 */ 258 int 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 268 EXPORT_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 */ 276 int snd_pcm_format_linear(snd_pcm_format_t format) 277 { 278 return snd_pcm_format_signed(format) >= 0; 279 } 280 281 EXPORT_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 */ 290 int 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 300 EXPORT_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 */ 309 int 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 319 EXPORT_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 */ 328 int 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 338 EXPORT_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 */ 347 int 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 357 EXPORT_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 */ 367 ssize_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 375 EXPORT_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 */ 383 const 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 392 EXPORT_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 */ 404 int 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 463 EXPORT_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 */ 474 int 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 492 EXPORT_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 */ 501 unsigned 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 } 510 EXPORT_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 */ 519 unsigned 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 } 528 EXPORT_SYMBOL(snd_pcm_rate_bit_to_rate); 529 530 static 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 */ 551 unsigned 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 } 567 EXPORT_SYMBOL_GPL(snd_pcm_rate_mask_intersect); 568