1 /* 2 * PCM Interface - misc routines 3 * Copyright (c) 1998 by Jaroslav Kysela <perex (at) 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 Lesser General Public License as 8 * published by the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details. 15 * 16 * You should have received a copy of the GNU Lesser 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 <stdio.h> 23 #include <stdlib.h> 24 #include <unistd.h> 25 #include <string.h> 26 #include <byteswap.h> 27 #include "pcm_local.h" 28 29 30 /** 31 * \brief Return sign info for a PCM sample linear format 32 * \param format Format 33 * \return 0 unsigned, 1 signed, a negative error code if format is not linear 34 */ 35 int snd_pcm_format_signed(snd_pcm_format_t format) 36 { 37 switch (format) { 38 case SNDRV_PCM_FORMAT_S8: 39 case SNDRV_PCM_FORMAT_S16_LE: 40 case SNDRV_PCM_FORMAT_S16_BE: 41 case SNDRV_PCM_FORMAT_S24_LE: 42 case SNDRV_PCM_FORMAT_S24_BE: 43 case SNDRV_PCM_FORMAT_S32_LE: 44 case SNDRV_PCM_FORMAT_S32_BE: 45 case SNDRV_PCM_FORMAT_S24_3LE: 46 case SNDRV_PCM_FORMAT_S24_3BE: 47 case SNDRV_PCM_FORMAT_S20_3LE: 48 case SNDRV_PCM_FORMAT_S20_3BE: 49 case SNDRV_PCM_FORMAT_S18_3LE: 50 case SNDRV_PCM_FORMAT_S18_3BE: 51 return 1; 52 case SNDRV_PCM_FORMAT_U8: 53 case SNDRV_PCM_FORMAT_U16_LE: 54 case SNDRV_PCM_FORMAT_U16_BE: 55 case SNDRV_PCM_FORMAT_U24_LE: 56 case SNDRV_PCM_FORMAT_U24_BE: 57 case SNDRV_PCM_FORMAT_U32_LE: 58 case SNDRV_PCM_FORMAT_U32_BE: 59 case SNDRV_PCM_FORMAT_U24_3LE: 60 case SNDRV_PCM_FORMAT_U24_3BE: 61 case SNDRV_PCM_FORMAT_U20_3LE: 62 case SNDRV_PCM_FORMAT_U20_3BE: 63 case SNDRV_PCM_FORMAT_U18_3LE: 64 case SNDRV_PCM_FORMAT_U18_3BE: 65 return 0; 66 default: 67 return -EINVAL; 68 } 69 } 70 71 /** 72 * \brief Return sign info for a PCM sample linear format 73 * \param format Format 74 * \return 0 signed, 1 unsigned, a negative error code if format is not linear 75 */ 76 int snd_pcm_format_unsigned(snd_pcm_format_t format) 77 { 78 int val; 79 80 val = snd_pcm_format_signed(format); 81 if (val < 0) 82 return val; 83 return !val; 84 } 85 86 /** 87 * \brief Return linear info for a PCM sample format 88 * \param format Format 89 * \return 0 non linear, 1 linear 90 */ 91 int snd_pcm_format_linear(snd_pcm_format_t format) 92 { 93 return snd_pcm_format_signed(format) >= 0; 94 } 95 96 /** 97 * \brief Return float info for a PCM sample format 98 * \param format Format 99 * \return 0 non float, 1 float 100 */ 101 int snd_pcm_format_float(snd_pcm_format_t format) 102 { 103 switch (format) { 104 case SNDRV_PCM_FORMAT_FLOAT_LE: 105 case SNDRV_PCM_FORMAT_FLOAT_BE: 106 case SNDRV_PCM_FORMAT_FLOAT64_LE: 107 case SNDRV_PCM_FORMAT_FLOAT64_BE: 108 return 1; 109 default: 110 return 0; 111 } 112 } 113 114 /** 115 * \brief Return endian info for a PCM sample format 116 * \param format Format 117 * \return 0 big endian, 1 little endian, a negative error code if endian independent 118 */ 119 int snd_pcm_format_little_endian(snd_pcm_format_t format) 120 { 121 switch (format) { 122 case SNDRV_PCM_FORMAT_S16_LE: 123 case SNDRV_PCM_FORMAT_U16_LE: 124 case SNDRV_PCM_FORMAT_S24_LE: 125 case SNDRV_PCM_FORMAT_U24_LE: 126 case SNDRV_PCM_FORMAT_S32_LE: 127 case SNDRV_PCM_FORMAT_U32_LE: 128 case SNDRV_PCM_FORMAT_FLOAT_LE: 129 case SNDRV_PCM_FORMAT_FLOAT64_LE: 130 case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE: 131 case SNDRV_PCM_FORMAT_S24_3LE: 132 case SNDRV_PCM_FORMAT_S20_3LE: 133 case SNDRV_PCM_FORMAT_S18_3LE: 134 case SNDRV_PCM_FORMAT_U24_3LE: 135 case SNDRV_PCM_FORMAT_U20_3LE: 136 case SNDRV_PCM_FORMAT_U18_3LE: 137 return 1; 138 case SNDRV_PCM_FORMAT_S16_BE: 139 case SNDRV_PCM_FORMAT_U16_BE: 140 case SNDRV_PCM_FORMAT_S24_BE: 141 case SNDRV_PCM_FORMAT_U24_BE: 142 case SNDRV_PCM_FORMAT_S32_BE: 143 case SNDRV_PCM_FORMAT_U32_BE: 144 case SNDRV_PCM_FORMAT_FLOAT_BE: 145 case SNDRV_PCM_FORMAT_FLOAT64_BE: 146 case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE: 147 case SNDRV_PCM_FORMAT_S24_3BE: 148 case SNDRV_PCM_FORMAT_S20_3BE: 149 case SNDRV_PCM_FORMAT_S18_3BE: 150 case SNDRV_PCM_FORMAT_U24_3BE: 151 case SNDRV_PCM_FORMAT_U20_3BE: 152 case SNDRV_PCM_FORMAT_U18_3BE: 153 return 0; 154 default: 155 return -EINVAL; 156 } 157 } 158 159 /** 160 * \brief Return endian info for a PCM sample format 161 * \param format Format 162 * \return 0 little endian, 1 big endian, a negative error code if endian independent 163 */ 164 int snd_pcm_format_big_endian(snd_pcm_format_t format) 165 { 166 int val; 167 168 val = snd_pcm_format_little_endian(format); 169 if (val < 0) 170 return val; 171 return !val; 172 } 173 174 /** 175 * \brief Return endian info for a PCM sample format 176 * \param format Format 177 * \return 0 swapped, 1 CPU endian, a negative error code if endian independent 178 */ 179 int snd_pcm_format_cpu_endian(snd_pcm_format_t format) 180 { 181 #ifdef SNDRV_LITTLE_ENDIAN 182 return snd_pcm_format_little_endian(format); 183 #else 184 return snd_pcm_format_big_endian(format); 185 #endif 186 } 187 188 /** 189 * \brief Return nominal bits per a PCM sample 190 * \param format Sample format 191 * \return bits per sample, a negative error code if not applicable 192 */ 193 int snd_pcm_format_width(snd_pcm_format_t format) 194 { 195 switch (format) { 196 case SNDRV_PCM_FORMAT_S8: 197 case SNDRV_PCM_FORMAT_U8: 198 return 8; 199 case SNDRV_PCM_FORMAT_S16_LE: 200 case SNDRV_PCM_FORMAT_S16_BE: 201 case SNDRV_PCM_FORMAT_U16_LE: 202 case SNDRV_PCM_FORMAT_U16_BE: 203 return 16; 204 case SNDRV_PCM_FORMAT_S18_3LE: 205 case SNDRV_PCM_FORMAT_S18_3BE: 206 case SNDRV_PCM_FORMAT_U18_3LE: 207 case SNDRV_PCM_FORMAT_U18_3BE: 208 return 18; 209 case SNDRV_PCM_FORMAT_S20_3LE: 210 case SNDRV_PCM_FORMAT_S20_3BE: 211 case SNDRV_PCM_FORMAT_U20_3LE: 212 case SNDRV_PCM_FORMAT_U20_3BE: 213 return 20; 214 case SNDRV_PCM_FORMAT_S24_LE: 215 case SNDRV_PCM_FORMAT_S24_BE: 216 case SNDRV_PCM_FORMAT_U24_LE: 217 case SNDRV_PCM_FORMAT_U24_BE: 218 case SNDRV_PCM_FORMAT_S24_3LE: 219 case SNDRV_PCM_FORMAT_S24_3BE: 220 case SNDRV_PCM_FORMAT_U24_3LE: 221 case SNDRV_PCM_FORMAT_U24_3BE: 222 return 24; 223 case SNDRV_PCM_FORMAT_S32_LE: 224 case SNDRV_PCM_FORMAT_S32_BE: 225 case SNDRV_PCM_FORMAT_U32_LE: 226 case SNDRV_PCM_FORMAT_U32_BE: 227 case SNDRV_PCM_FORMAT_FLOAT_LE: 228 case SNDRV_PCM_FORMAT_FLOAT_BE: 229 return 32; 230 case SNDRV_PCM_FORMAT_FLOAT64_LE: 231 case SNDRV_PCM_FORMAT_FLOAT64_BE: 232 return 64; 233 case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE: 234 case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE: 235 return 32; 236 case SNDRV_PCM_FORMAT_MU_LAW: 237 case SNDRV_PCM_FORMAT_A_LAW: 238 return 8; 239 case SNDRV_PCM_FORMAT_IMA_ADPCM: 240 return 4; 241 default: 242 return -EINVAL; 243 } 244 } 245 246 /** 247 * \brief Return bits needed to store a PCM sample 248 * \param format Sample format 249 * \return bits per sample, a negative error code if not applicable 250 */ 251 int snd_pcm_format_physical_width(snd_pcm_format_t format) 252 { 253 switch (format) { 254 case SNDRV_PCM_FORMAT_S8: 255 case SNDRV_PCM_FORMAT_U8: 256 return 8; 257 case SNDRV_PCM_FORMAT_S16_LE: 258 case SNDRV_PCM_FORMAT_S16_BE: 259 case SNDRV_PCM_FORMAT_U16_LE: 260 case SNDRV_PCM_FORMAT_U16_BE: 261 return 16; 262 case SNDRV_PCM_FORMAT_S18_3LE: 263 case SNDRV_PCM_FORMAT_S18_3BE: 264 case SNDRV_PCM_FORMAT_U18_3LE: 265 case SNDRV_PCM_FORMAT_U18_3BE: 266 case SNDRV_PCM_FORMAT_S20_3LE: 267 case SNDRV_PCM_FORMAT_S20_3BE: 268 case SNDRV_PCM_FORMAT_U20_3LE: 269 case SNDRV_PCM_FORMAT_U20_3BE: 270 case SNDRV_PCM_FORMAT_S24_3LE: 271 case SNDRV_PCM_FORMAT_S24_3BE: 272 case SNDRV_PCM_FORMAT_U24_3LE: 273 case SNDRV_PCM_FORMAT_U24_3BE: 274 return 24; 275 case SNDRV_PCM_FORMAT_S24_LE: 276 case SNDRV_PCM_FORMAT_S24_BE: 277 case SNDRV_PCM_FORMAT_U24_LE: 278 case SNDRV_PCM_FORMAT_U24_BE: 279 case SNDRV_PCM_FORMAT_S32_LE: 280 case SNDRV_PCM_FORMAT_S32_BE: 281 case SNDRV_PCM_FORMAT_U32_LE: 282 case SNDRV_PCM_FORMAT_U32_BE: 283 case SNDRV_PCM_FORMAT_FLOAT_LE: 284 case SNDRV_PCM_FORMAT_FLOAT_BE: 285 case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE: 286 case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE: 287 return 32; 288 case SNDRV_PCM_FORMAT_FLOAT64_LE: 289 case SNDRV_PCM_FORMAT_FLOAT64_BE: 290 return 64; 291 case SNDRV_PCM_FORMAT_MU_LAW: 292 case SNDRV_PCM_FORMAT_A_LAW: 293 return 8; 294 case SNDRV_PCM_FORMAT_IMA_ADPCM: 295 return 4; 296 default: 297 return -EINVAL; 298 } 299 } 300 301 /** 302 * \brief Return bytes needed to store a quantity of PCM sample 303 * \param format Sample format 304 * \param samples Samples count 305 * \return bytes needed, a negative error code if not integer or unknown 306 */ 307 ssize_t snd_pcm_format_size(snd_pcm_format_t format, size_t samples) 308 { 309 switch (format) { 310 case SNDRV_PCM_FORMAT_S8: 311 case SNDRV_PCM_FORMAT_U8: 312 return samples; 313 case SNDRV_PCM_FORMAT_S16_LE: 314 case SNDRV_PCM_FORMAT_S16_BE: 315 case SNDRV_PCM_FORMAT_U16_LE: 316 case SNDRV_PCM_FORMAT_U16_BE: 317 return samples * 2; 318 case SNDRV_PCM_FORMAT_S18_3LE: 319 case SNDRV_PCM_FORMAT_S18_3BE: 320 case SNDRV_PCM_FORMAT_U18_3LE: 321 case SNDRV_PCM_FORMAT_U18_3BE: 322 case SNDRV_PCM_FORMAT_S20_3LE: 323 case SNDRV_PCM_FORMAT_S20_3BE: 324 case SNDRV_PCM_FORMAT_U20_3LE: 325 case SNDRV_PCM_FORMAT_U20_3BE: 326 case SNDRV_PCM_FORMAT_S24_3LE: 327 case SNDRV_PCM_FORMAT_S24_3BE: 328 case SNDRV_PCM_FORMAT_U24_3LE: 329 case SNDRV_PCM_FORMAT_U24_3BE: 330 return samples * 3; 331 case SNDRV_PCM_FORMAT_S24_LE: 332 case SNDRV_PCM_FORMAT_S24_BE: 333 case SNDRV_PCM_FORMAT_U24_LE: 334 case SNDRV_PCM_FORMAT_U24_BE: 335 case SNDRV_PCM_FORMAT_S32_LE: 336 case SNDRV_PCM_FORMAT_S32_BE: 337 case SNDRV_PCM_FORMAT_U32_LE: 338 case SNDRV_PCM_FORMAT_U32_BE: 339 case SNDRV_PCM_FORMAT_FLOAT_LE: 340 case SNDRV_PCM_FORMAT_FLOAT_BE: 341 return samples * 4; 342 case SNDRV_PCM_FORMAT_FLOAT64_LE: 343 case SNDRV_PCM_FORMAT_FLOAT64_BE: 344 return samples * 8; 345 case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE: 346 case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE: 347 return samples * 4; 348 case SNDRV_PCM_FORMAT_MU_LAW: 349 case SNDRV_PCM_FORMAT_A_LAW: 350 return samples; 351 case SNDRV_PCM_FORMAT_IMA_ADPCM: 352 if (samples & 1) 353 return -EINVAL; 354 return samples / 2; 355 default: 356 assert(0); 357 return -EINVAL; 358 } 359 } 360 361 /** 362 * \brief Return 64 bit expressing silence for a PCM sample format 363 * \param format Sample format 364 * \return silence 64 bit word 365 */ 366 u_int64_t snd_pcm_format_silence_64(snd_pcm_format_t format) 367 { 368 switch (format) { 369 case SNDRV_PCM_FORMAT_S8: 370 case SNDRV_PCM_FORMAT_S16_LE: 371 case SNDRV_PCM_FORMAT_S16_BE: 372 case SNDRV_PCM_FORMAT_S24_LE: 373 case SNDRV_PCM_FORMAT_S24_BE: 374 case SNDRV_PCM_FORMAT_S32_LE: 375 case SNDRV_PCM_FORMAT_S32_BE: 376 case SNDRV_PCM_FORMAT_S24_3LE: 377 case SNDRV_PCM_FORMAT_S24_3BE: 378 case SNDRV_PCM_FORMAT_S20_3LE: 379 case SNDRV_PCM_FORMAT_S20_3BE: 380 case SNDRV_PCM_FORMAT_S18_3LE: 381 case SNDRV_PCM_FORMAT_S18_3BE: 382 return 0; 383 case SNDRV_PCM_FORMAT_U8: 384 return 0x8080808080808080ULL; 385 #ifdef SNDRV_LITTLE_ENDIAN 386 case SNDRV_PCM_FORMAT_U16_LE: 387 return 0x8000800080008000ULL; 388 case SNDRV_PCM_FORMAT_U24_LE: 389 return 0x0080000000800000ULL; 390 case SNDRV_PCM_FORMAT_U32_LE: 391 return 0x8000000080000000ULL; 392 case SNDRV_PCM_FORMAT_U16_BE: 393 return 0x0080008000800080ULL; 394 case SNDRV_PCM_FORMAT_U24_BE: 395 return 0x0000800000008000ULL; 396 case SNDRV_PCM_FORMAT_U32_BE: 397 return 0x0000008000000080ULL; 398 case SNDRV_PCM_FORMAT_U24_3LE: 399 return 0x0000800000800000ULL; 400 case SNDRV_PCM_FORMAT_U24_3BE: 401 return 0x0080000080000080ULL; 402 case SNDRV_PCM_FORMAT_U20_3LE: 403 return 0x0000080000080000ULL; 404 case SNDRV_PCM_FORMAT_U20_3BE: 405 return 0x0008000008000008ULL; 406 case SNDRV_PCM_FORMAT_U18_3LE: 407 return 0x0000020000020000ULL; 408 case SNDRV_PCM_FORMAT_U18_3BE: 409 return 0x0002000002000002ULL; 410 #else 411 case SNDRV_PCM_FORMAT_U16_LE: 412 return 0x0080008000800080ULL; 413 case SNDRV_PCM_FORMAT_U24_LE: 414 return 0x0000800000008000ULL; 415 case SNDRV_PCM_FORMAT_U32_LE: 416 return 0x0000008000000080ULL; 417 case SNDRV_PCM_FORMAT_U16_BE: 418 return 0x8000800080008000ULL; 419 case SNDRV_PCM_FORMAT_U24_BE: 420 return 0x0080000000800000ULL; 421 case SNDRV_PCM_FORMAT_U32_BE: 422 return 0x8000000080000000ULL; 423 case SNDRV_PCM_FORMAT_U24_3LE: 424 return 0x0080000080000080ULL; 425 case SNDRV_PCM_FORMAT_U24_3BE: 426 return 0x0000800000800000ULL; 427 case SNDRV_PCM_FORMAT_U20_3LE: 428 return 0x0008000008000008ULL; 429 case SNDRV_PCM_FORMAT_U20_3BE: 430 return 0x0000080000080000ULL; 431 case SNDRV_PCM_FORMAT_U18_3LE: 432 return 0x0002000002000002ULL; 433 case SNDRV_PCM_FORMAT_U18_3BE: 434 return 0x0000020000020000ULL; 435 #endif 436 case SNDRV_PCM_FORMAT_FLOAT_LE: 437 { 438 union { 439 float f[2]; 440 u_int64_t i; 441 } u; 442 u.f[0] = u.f[1] = 0.0; 443 #ifdef SNDRV_LITTLE_ENDIAN 444 return u.i; 445 #else 446 return bswap_64(u.i); 447 #endif 448 } 449 case SNDRV_PCM_FORMAT_FLOAT64_LE: 450 { 451 union { 452 double f; 453 u_int64_t i; 454 } u; 455 u.f = 0.0; 456 #ifdef SNDRV_LITTLE_ENDIAN 457 return u.i; 458 #else 459 return bswap_64(u.i); 460 #endif 461 } 462 case SNDRV_PCM_FORMAT_FLOAT_BE: 463 { 464 union { 465 float f[2]; 466 u_int64_t i; 467 } u; 468 u.f[0] = u.f[1] = 0.0; 469 #ifdef SNDRV_LITTLE_ENDIAN 470 return bswap_64(u.i); 471 #else 472 return u.i; 473 #endif 474 } 475 case SNDRV_PCM_FORMAT_FLOAT64_BE: 476 { 477 union { 478 double f; 479 u_int64_t i; 480 } u; 481 u.f = 0.0; 482 #ifdef SNDRV_LITTLE_ENDIAN 483 return bswap_64(u.i); 484 #else 485 return u.i; 486 #endif 487 } 488 case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE: 489 case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE: 490 return 0; 491 case SNDRV_PCM_FORMAT_MU_LAW: 492 return 0x7f7f7f7f7f7f7f7fULL; 493 case SNDRV_PCM_FORMAT_A_LAW: 494 return 0x5555555555555555ULL; 495 case SNDRV_PCM_FORMAT_IMA_ADPCM: /* special case */ 496 case SNDRV_PCM_FORMAT_MPEG: 497 case SNDRV_PCM_FORMAT_GSM: 498 case SNDRV_PCM_FORMAT_SPECIAL: 499 return 0; 500 default: 501 assert(0); 502 return 0; 503 } 504 return 0; 505 } 506 507 /** 508 * \brief Return 32 bit expressing silence for a PCM sample format 509 * \param format Sample format 510 * \return silence 32 bit word 511 */ 512 u_int32_t snd_pcm_format_silence_32(snd_pcm_format_t format) 513 { 514 assert(snd_pcm_format_physical_width(format) <= 32); 515 return (u_int32_t)snd_pcm_format_silence_64(format); 516 } 517 518 /** 519 * \brief Return 16 bit expressing silence for a PCM sample format 520 * \param format Sample format 521 * \return silence 16 bit word 522 */ 523 u_int16_t snd_pcm_format_silence_16(snd_pcm_format_t format) 524 { 525 assert(snd_pcm_format_physical_width(format) <= 16); 526 return (u_int16_t)snd_pcm_format_silence_64(format); 527 } 528 529 /** 530 * \brief Return 8 bit expressing silence for a PCM sample format 531 * \param format Sample format 532 * \return silence 8 bit word 533 */ 534 u_int8_t snd_pcm_format_silence(snd_pcm_format_t format) 535 { 536 assert(snd_pcm_format_physical_width(format) <= 8); 537 return (u_int8_t)snd_pcm_format_silence_64(format); 538 } 539 540 /** 541 * \brief Silence a PCM samples buffer 542 * \param format Sample format 543 * \param data Buffer 544 * \param samples Samples count 545 * \return 0 if successful or a negative error code 546 */ 547 int snd_pcm_format_set_silence(snd_pcm_format_t format, void *data, unsigned int samples) 548 { 549 if (samples == 0) 550 return 0; 551 switch (snd_pcm_format_physical_width(format)) { 552 case 4: { 553 u_int8_t silence = snd_pcm_format_silence_64(format); 554 unsigned int samples1; 555 if (samples % 2 != 0) 556 return -EINVAL; 557 samples1 = samples / 2; 558 memset(data, silence, samples1); 559 break; 560 } 561 case 8: { 562 u_int8_t silence = snd_pcm_format_silence_64(format); 563 memset(data, silence, samples); 564 break; 565 } 566 case 16: { 567 u_int16_t silence = snd_pcm_format_silence_64(format); 568 u_int16_t *pdata = (u_int16_t *)data; 569 if (! silence) 570 memset(data, 0, samples * 2); 571 else { 572 while (samples-- > 0) 573 *pdata++ = silence; 574 } 575 break; 576 } 577 case 24: { 578 u_int32_t silence = snd_pcm_format_silence_64(format); 579 u_int8_t *pdata = (u_int8_t *)data; 580 if (! silence) 581 memset(data, 0, samples * 3); 582 else { 583 while (samples-- > 0) { 584 #ifdef SNDRV_LITTLE_ENDIAN 585 *pdata++ = silence >> 0; 586 *pdata++ = silence >> 8; 587 *pdata++ = silence >> 16; 588 #else 589 *pdata++ = silence >> 16; 590 *pdata++ = silence >> 8; 591 *pdata++ = silence >> 0; 592 #endif 593 } 594 } 595 break; 596 } 597 case 32: { 598 u_int32_t silence = snd_pcm_format_silence_64(format); 599 u_int32_t *pdata = (u_int32_t *)data; 600 if (! silence) 601 memset(data, 0, samples * 4); 602 else { 603 while (samples-- > 0) 604 *pdata++ = silence; 605 } 606 break; 607 } 608 case 64: { 609 u_int64_t silence = snd_pcm_format_silence_64(format); 610 u_int64_t *pdata = (u_int64_t *)data; 611 if (! silence) 612 memset(data, 0, samples * 8); 613 else { 614 while (samples-- > 0) 615 *pdata++ = silence; 616 } 617 break; 618 } 619 default: 620 assert(0); 621 return -EINVAL; 622 } 623 return 0; 624 } 625 626 static const int linear_formats[4][2][2] = { 627 { { SNDRV_PCM_FORMAT_S8, SNDRV_PCM_FORMAT_S8 }, 628 { SNDRV_PCM_FORMAT_U8, SNDRV_PCM_FORMAT_U8 } }, 629 { { SNDRV_PCM_FORMAT_S16_LE, SNDRV_PCM_FORMAT_S16_BE }, 630 { SNDRV_PCM_FORMAT_U16_LE, SNDRV_PCM_FORMAT_U16_BE } }, 631 { { SNDRV_PCM_FORMAT_S24_LE, SNDRV_PCM_FORMAT_S24_BE }, 632 { SNDRV_PCM_FORMAT_U24_LE, SNDRV_PCM_FORMAT_U24_BE } }, 633 { { SNDRV_PCM_FORMAT_S32_LE, SNDRV_PCM_FORMAT_S32_BE }, 634 { SNDRV_PCM_FORMAT_U32_LE, SNDRV_PCM_FORMAT_U32_BE } } 635 }; 636 637 static const int linear24_formats[3][2][2] = { 638 { { SNDRV_PCM_FORMAT_S24_3LE, SNDRV_PCM_FORMAT_S24_3BE }, 639 { SNDRV_PCM_FORMAT_U24_3LE, SNDRV_PCM_FORMAT_U24_3BE } }, 640 { { SNDRV_PCM_FORMAT_S20_3LE, SNDRV_PCM_FORMAT_S20_3BE }, 641 { SNDRV_PCM_FORMAT_U20_3LE, SNDRV_PCM_FORMAT_U20_3BE } }, 642 { { SNDRV_PCM_FORMAT_S18_3LE, SNDRV_PCM_FORMAT_S18_3BE }, 643 { SNDRV_PCM_FORMAT_U18_3LE, SNDRV_PCM_FORMAT_U18_3BE } }, 644 }; 645 646 /** 647 * \brief Compose a PCM sample linear format 648 * \param width Nominal bits per sample 649 * \param pwidth Physical bit width of the format 650 * \param unsignd Sign: 0 signed, 1 unsigned 651 * \param big_endian Endian: 0 little endian, 1 big endian 652 * \return The matching format type, or #SND_PCM_FORMAT_UNKNOWN if no match 653 */ 654 snd_pcm_format_t snd_pcm_build_linear_format(int width, int pwidth, int unsignd, int big_endian) 655 { 656 if (pwidth == 24) { 657 switch (width) { 658 case 24: 659 width = 0; 660 break; 661 case 20: 662 width = 1; 663 break; 664 case 18: 665 width = 2; 666 break; 667 default: 668 return SND_PCM_FORMAT_UNKNOWN; 669 } 670 return linear24_formats[width][!!unsignd][!!big_endian]; 671 } else { 672 switch (width) { 673 case 8: 674 width = 0; 675 break; 676 case 16: 677 width = 1; 678 break; 679 case 24: 680 width = 2; 681 break; 682 case 32: 683 width = 3; 684 break; 685 default: 686 return SND_PCM_FORMAT_UNKNOWN; 687 } 688 return linear_formats[width][!!unsignd][!!big_endian]; 689 } 690 } 691 692 /** 693 * \brief Parse control element id from the config 694 * \param conf the config tree to parse 695 * \param ctl_id the pointer to store the resultant control element id 696 * \param cardp the pointer to store the card index 697 * \param cchannelsp the pointer to store the number of channels (optional) 698 * \param hwctlp the pointer to store the h/w control flag (optional) 699 * \return 0 if successful, or a negative error code 700 * 701 * This function parses the given config tree to retrieve the control element id 702 * and the card index. It's used by softvol. External PCM plugins can use this 703 * function for creating or assigining their controls. 704 * 705 * cchannelsp and hwctlp arguments are optional. Set NULL if not necessary. 706 */ 707 int snd_pcm_parse_control_id(snd_config_t *conf, snd_ctl_elem_id_t *ctl_id, int *cardp, 708 int *cchannelsp, int *hwctlp) 709 { 710 snd_config_iterator_t i, next; 711 int iface = SND_CTL_ELEM_IFACE_MIXER; 712 const char *name = NULL; 713 long index = 0; 714 long device = -1; 715 long subdevice = -1; 716 int err; 717 718 assert(ctl_id && cardp); 719 720 *cardp = -1; 721 if (cchannelsp) 722 *cchannelsp = 2; 723 snd_config_for_each(i, next, conf) { 724 snd_config_t *n = snd_config_iterator_entry(i); 725 const char *id; 726 if (snd_config_get_id(n, &id) < 0) 727 continue; 728 if (strcmp(id, "comment") == 0) 729 continue; 730 if (strcmp(id, "card") == 0) { 731 const char *str; 732 long v; 733 if ((err = snd_config_get_integer(n, &v)) < 0) { 734 if ((err = snd_config_get_string(n, &str)) < 0) { 735 SNDERR("Invalid field %s", id); 736 goto _err; 737 } 738 *cardp = snd_card_get_index(str); 739 if (*cardp < 0) { 740 SNDERR("Cannot get index for %s", str); 741 err = *cardp; 742 goto _err; 743 } 744 } else 745 *cardp = v; 746 continue; 747 } 748 if (strcmp(id, "iface") == 0 || strcmp(id, "interface") == 0) { 749 const char *ptr; 750 if ((err = snd_config_get_string(n, &ptr)) < 0) { 751 SNDERR("field %s is not a string", id); 752 goto _err; 753 } 754 if ((err = snd_config_get_ctl_iface_ascii(ptr)) < 0) { 755 SNDERR("Invalid value for '%s'", id); 756 goto _err; 757 } 758 iface = err; 759 continue; 760 } 761 if (strcmp(id, "name") == 0) { 762 if ((err = snd_config_get_string(n, &name)) < 0) { 763 SNDERR("field %s is not a string", id); 764 goto _err; 765 } 766 continue; 767 } 768 if (strcmp(id, "index") == 0) { 769 if ((err = snd_config_get_integer(n, &index)) < 0) { 770 SNDERR("field %s is not an integer", id); 771 goto _err; 772 } 773 continue; 774 } 775 if (strcmp(id, "device") == 0) { 776 if ((err = snd_config_get_integer(n, &device)) < 0) { 777 SNDERR("field %s is not an integer", id); 778 goto _err; 779 } 780 continue; 781 } 782 if (strcmp(id, "subdevice") == 0) { 783 if ((err = snd_config_get_integer(n, &subdevice)) < 0) { 784 SNDERR("field %s is not an integer", id); 785 goto _err; 786 } 787 continue; 788 } 789 if (cchannelsp && strcmp(id, "count") == 0) { 790 long v; 791 if ((err = snd_config_get_integer(n, &v)) < 0) { 792 SNDERR("field %s is not an integer", id); 793 goto _err; 794 } 795 if (v < 1 || v > 2) { 796 SNDERR("Invalid count %ld", v); 797 goto _err; 798 } 799 *cchannelsp = v; 800 continue; 801 } 802 if (hwctlp && strcmp(id, "hwctl") == 0) { 803 if ((err = snd_config_get_bool(n)) < 0) { 804 SNDERR("The field %s must be a boolean type", id); 805 return err; 806 } 807 *hwctlp = err; 808 continue; 809 } 810 SNDERR("Unknown field %s", id); 811 return -EINVAL; 812 } 813 if (name == NULL) { 814 SNDERR("Missing control name"); 815 err = -EINVAL; 816 goto _err; 817 } 818 if (device < 0) 819 device = 0; 820 if (subdevice < 0) 821 subdevice = 0; 822 823 snd_ctl_elem_id_set_interface(ctl_id, iface); 824 snd_ctl_elem_id_set_name(ctl_id, name); 825 snd_ctl_elem_id_set_index(ctl_id, index); 826 snd_ctl_elem_id_set_device(ctl_id, device); 827 snd_ctl_elem_id_set_subdevice(ctl_id, subdevice); 828 829 return 0; 830 831 _err: 832 return err; 833 } 834
