1 /* 2 * PCM Plug-In shared (kernel/library) code 3 * Copyright (c) 1999 by Jaroslav Kysela <perex@perex.cz> 4 * Copyright (c) 2000 by Abramo Bagnara <abramo@alsa-project.org> 5 * 6 * 7 * This library is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU Library General Public License as 9 * published by the Free Software Foundation; either version 2 of 10 * the License, or (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU Library General Public License for more details. 16 * 17 * You should have received a copy of the GNU Library General Public 18 * License along with this library; if not, write to the Free Software 19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 20 * 21 */ 22 23 #if 0 24 #define PLUGIN_DEBUG 25 #endif 26 27 #include <linux/slab.h> 28 #include <linux/time.h> 29 #include <linux/vmalloc.h> 30 #include <sound/core.h> 31 #include <sound/pcm.h> 32 #include <sound/pcm_params.h> 33 #include "pcm_plugin.h" 34 35 #define snd_pcm_plug_first(plug) ((plug)->runtime->oss.plugin_first) 36 #define snd_pcm_plug_last(plug) ((plug)->runtime->oss.plugin_last) 37 38 /* 39 * because some cards might have rates "very close", we ignore 40 * all "resampling" requests within +-5% 41 */ 42 static int rate_match(unsigned int src_rate, unsigned int dst_rate) 43 { 44 unsigned int low = (src_rate * 95) / 100; 45 unsigned int high = (src_rate * 105) / 100; 46 return dst_rate >= low && dst_rate <= high; 47 } 48 49 static int snd_pcm_plugin_alloc(struct snd_pcm_plugin *plugin, snd_pcm_uframes_t frames) 50 { 51 struct snd_pcm_plugin_format *format; 52 ssize_t width; 53 size_t size; 54 unsigned int channel; 55 struct snd_pcm_plugin_channel *c; 56 57 if (plugin->stream == SNDRV_PCM_STREAM_PLAYBACK) { 58 format = &plugin->src_format; 59 } else { 60 format = &plugin->dst_format; 61 } 62 if ((width = snd_pcm_format_physical_width(format->format)) < 0) 63 return width; 64 size = frames * format->channels * width; 65 if (snd_BUG_ON(size % 8)) 66 return -ENXIO; 67 size /= 8; 68 if (plugin->buf_frames < frames) { 69 kvfree(plugin->buf); 70 plugin->buf = kvzalloc(size, GFP_KERNEL); 71 plugin->buf_frames = frames; 72 } 73 if (!plugin->buf) { 74 plugin->buf_frames = 0; 75 return -ENOMEM; 76 } 77 c = plugin->buf_channels; 78 if (plugin->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED) { 79 for (channel = 0; channel < format->channels; channel++, c++) { 80 c->frames = frames; 81 c->enabled = 1; 82 c->wanted = 0; 83 c->area.addr = plugin->buf; 84 c->area.first = channel * width; 85 c->area.step = format->channels * width; 86 } 87 } else if (plugin->access == SNDRV_PCM_ACCESS_RW_NONINTERLEAVED) { 88 if (snd_BUG_ON(size % format->channels)) 89 return -EINVAL; 90 size /= format->channels; 91 for (channel = 0; channel < format->channels; channel++, c++) { 92 c->frames = frames; 93 c->enabled = 1; 94 c->wanted = 0; 95 c->area.addr = plugin->buf + (channel * size); 96 c->area.first = 0; 97 c->area.step = width; 98 } 99 } else 100 return -EINVAL; 101 return 0; 102 } 103 104 int snd_pcm_plug_alloc(struct snd_pcm_substream *plug, snd_pcm_uframes_t frames) 105 { 106 int err; 107 if (snd_BUG_ON(!snd_pcm_plug_first(plug))) 108 return -ENXIO; 109 if (snd_pcm_plug_stream(plug) == SNDRV_PCM_STREAM_PLAYBACK) { 110 struct snd_pcm_plugin *plugin = snd_pcm_plug_first(plug); 111 while (plugin->next) { 112 if (plugin->dst_frames) 113 frames = plugin->dst_frames(plugin, frames); 114 if ((snd_pcm_sframes_t)frames <= 0) 115 return -ENXIO; 116 plugin = plugin->next; 117 err = snd_pcm_plugin_alloc(plugin, frames); 118 if (err < 0) 119 return err; 120 } 121 } else { 122 struct snd_pcm_plugin *plugin = snd_pcm_plug_last(plug); 123 while (plugin->prev) { 124 if (plugin->src_frames) 125 frames = plugin->src_frames(plugin, frames); 126 if ((snd_pcm_sframes_t)frames <= 0) 127 return -ENXIO; 128 plugin = plugin->prev; 129 err = snd_pcm_plugin_alloc(plugin, frames); 130 if (err < 0) 131 return err; 132 } 133 } 134 return 0; 135 } 136 137 138 snd_pcm_sframes_t snd_pcm_plugin_client_channels(struct snd_pcm_plugin *plugin, 139 snd_pcm_uframes_t frames, 140 struct snd_pcm_plugin_channel **channels) 141 { 142 *channels = plugin->buf_channels; 143 return frames; 144 } 145 146 int snd_pcm_plugin_build(struct snd_pcm_substream *plug, 147 const char *name, 148 struct snd_pcm_plugin_format *src_format, 149 struct snd_pcm_plugin_format *dst_format, 150 size_t extra, 151 struct snd_pcm_plugin **ret) 152 { 153 struct snd_pcm_plugin *plugin; 154 unsigned int channels; 155 156 if (snd_BUG_ON(!plug)) 157 return -ENXIO; 158 if (snd_BUG_ON(!src_format || !dst_format)) 159 return -ENXIO; 160 plugin = kzalloc(sizeof(*plugin) + extra, GFP_KERNEL); 161 if (plugin == NULL) 162 return -ENOMEM; 163 plugin->name = name; 164 plugin->plug = plug; 165 plugin->stream = snd_pcm_plug_stream(plug); 166 plugin->access = SNDRV_PCM_ACCESS_RW_INTERLEAVED; 167 plugin->src_format = *src_format; 168 plugin->src_width = snd_pcm_format_physical_width(src_format->format); 169 snd_BUG_ON(plugin->src_width <= 0); 170 plugin->dst_format = *dst_format; 171 plugin->dst_width = snd_pcm_format_physical_width(dst_format->format); 172 snd_BUG_ON(plugin->dst_width <= 0); 173 if (plugin->stream == SNDRV_PCM_STREAM_PLAYBACK) 174 channels = src_format->channels; 175 else 176 channels = dst_format->channels; 177 plugin->buf_channels = kcalloc(channels, sizeof(*plugin->buf_channels), GFP_KERNEL); 178 if (plugin->buf_channels == NULL) { 179 snd_pcm_plugin_free(plugin); 180 return -ENOMEM; 181 } 182 plugin->client_channels = snd_pcm_plugin_client_channels; 183 *ret = plugin; 184 return 0; 185 } 186 187 int snd_pcm_plugin_free(struct snd_pcm_plugin *plugin) 188 { 189 if (! plugin) 190 return 0; 191 if (plugin->private_free) 192 plugin->private_free(plugin); 193 kfree(plugin->buf_channels); 194 kvfree(plugin->buf); 195 kfree(plugin); 196 return 0; 197 } 198 199 snd_pcm_sframes_t snd_pcm_plug_client_size(struct snd_pcm_substream *plug, snd_pcm_uframes_t drv_frames) 200 { 201 struct snd_pcm_plugin *plugin, *plugin_prev, *plugin_next; 202 int stream; 203 204 if (snd_BUG_ON(!plug)) 205 return -ENXIO; 206 if (drv_frames == 0) 207 return 0; 208 stream = snd_pcm_plug_stream(plug); 209 if (stream == SNDRV_PCM_STREAM_PLAYBACK) { 210 plugin = snd_pcm_plug_last(plug); 211 while (plugin && drv_frames > 0) { 212 if (drv_frames > plugin->buf_frames) 213 drv_frames = plugin->buf_frames; 214 plugin_prev = plugin->prev; 215 if (plugin->src_frames) 216 drv_frames = plugin->src_frames(plugin, drv_frames); 217 plugin = plugin_prev; 218 } 219 } else if (stream == SNDRV_PCM_STREAM_CAPTURE) { 220 plugin = snd_pcm_plug_first(plug); 221 while (plugin && drv_frames > 0) { 222 plugin_next = plugin->next; 223 if (plugin->dst_frames) 224 drv_frames = plugin->dst_frames(plugin, drv_frames); 225 if (drv_frames > plugin->buf_frames) 226 drv_frames = plugin->buf_frames; 227 plugin = plugin_next; 228 } 229 } else 230 snd_BUG(); 231 return drv_frames; 232 } 233 234 snd_pcm_sframes_t snd_pcm_plug_slave_size(struct snd_pcm_substream *plug, snd_pcm_uframes_t clt_frames) 235 { 236 struct snd_pcm_plugin *plugin, *plugin_prev, *plugin_next; 237 snd_pcm_sframes_t frames; 238 int stream; 239 240 if (snd_BUG_ON(!plug)) 241 return -ENXIO; 242 if (clt_frames == 0) 243 return 0; 244 frames = clt_frames; 245 stream = snd_pcm_plug_stream(plug); 246 if (stream == SNDRV_PCM_STREAM_PLAYBACK) { 247 plugin = snd_pcm_plug_first(plug); 248 while (plugin && frames > 0) { 249 plugin_next = plugin->next; 250 if (plugin->dst_frames) { 251 frames = plugin->dst_frames(plugin, frames); 252 if (frames < 0) 253 return frames; 254 } 255 if (frames > plugin->buf_frames) 256 frames = plugin->buf_frames; 257 plugin = plugin_next; 258 } 259 } else if (stream == SNDRV_PCM_STREAM_CAPTURE) { 260 plugin = snd_pcm_plug_last(plug); 261 while (plugin) { 262 if (frames > plugin->buf_frames) 263 frames = plugin->buf_frames; 264 plugin_prev = plugin->prev; 265 if (plugin->src_frames) { 266 frames = plugin->src_frames(plugin, frames); 267 if (frames < 0) 268 return frames; 269 } 270 plugin = plugin_prev; 271 } 272 } else 273 snd_BUG(); 274 return frames; 275 } 276 277 static int snd_pcm_plug_formats(const struct snd_mask *mask, 278 snd_pcm_format_t format) 279 { 280 struct snd_mask formats = *mask; 281 u64 linfmts = (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S8 | 282 SNDRV_PCM_FMTBIT_U16_LE | SNDRV_PCM_FMTBIT_S16_LE | 283 SNDRV_PCM_FMTBIT_U16_BE | SNDRV_PCM_FMTBIT_S16_BE | 284 SNDRV_PCM_FMTBIT_U24_LE | SNDRV_PCM_FMTBIT_S24_LE | 285 SNDRV_PCM_FMTBIT_U24_BE | SNDRV_PCM_FMTBIT_S24_BE | 286 SNDRV_PCM_FMTBIT_U24_3LE | SNDRV_PCM_FMTBIT_S24_3LE | 287 SNDRV_PCM_FMTBIT_U24_3BE | SNDRV_PCM_FMTBIT_S24_3BE | 288 SNDRV_PCM_FMTBIT_U32_LE | SNDRV_PCM_FMTBIT_S32_LE | 289 SNDRV_PCM_FMTBIT_U32_BE | SNDRV_PCM_FMTBIT_S32_BE); 290 snd_mask_set(&formats, (__force int)SNDRV_PCM_FORMAT_MU_LAW); 291 292 if (formats.bits[0] & lower_32_bits(linfmts)) 293 formats.bits[0] |= lower_32_bits(linfmts); 294 if (formats.bits[1] & upper_32_bits(linfmts)) 295 formats.bits[1] |= upper_32_bits(linfmts); 296 return snd_mask_test(&formats, (__force int)format); 297 } 298 299 static const snd_pcm_format_t preferred_formats[] = { 300 SNDRV_PCM_FORMAT_S16_LE, 301 SNDRV_PCM_FORMAT_S16_BE, 302 SNDRV_PCM_FORMAT_U16_LE, 303 SNDRV_PCM_FORMAT_U16_BE, 304 SNDRV_PCM_FORMAT_S24_3LE, 305 SNDRV_PCM_FORMAT_S24_3BE, 306 SNDRV_PCM_FORMAT_U24_3LE, 307 SNDRV_PCM_FORMAT_U24_3BE, 308 SNDRV_PCM_FORMAT_S24_LE, 309 SNDRV_PCM_FORMAT_S24_BE, 310 SNDRV_PCM_FORMAT_U24_LE, 311 SNDRV_PCM_FORMAT_U24_BE, 312 SNDRV_PCM_FORMAT_S32_LE, 313 SNDRV_PCM_FORMAT_S32_BE, 314 SNDRV_PCM_FORMAT_U32_LE, 315 SNDRV_PCM_FORMAT_U32_BE, 316 SNDRV_PCM_FORMAT_S8, 317 SNDRV_PCM_FORMAT_U8 318 }; 319 320 snd_pcm_format_t snd_pcm_plug_slave_format(snd_pcm_format_t format, 321 const struct snd_mask *format_mask) 322 { 323 int i; 324 325 if (snd_mask_test(format_mask, (__force int)format)) 326 return format; 327 if (!snd_pcm_plug_formats(format_mask, format)) 328 return (__force snd_pcm_format_t)-EINVAL; 329 if (snd_pcm_format_linear(format)) { 330 unsigned int width = snd_pcm_format_width(format); 331 int unsignd = snd_pcm_format_unsigned(format) > 0; 332 int big = snd_pcm_format_big_endian(format) > 0; 333 unsigned int badness, best = -1; 334 snd_pcm_format_t best_format = (__force snd_pcm_format_t)-1; 335 for (i = 0; i < ARRAY_SIZE(preferred_formats); i++) { 336 snd_pcm_format_t f = preferred_formats[i]; 337 unsigned int w; 338 if (!snd_mask_test(format_mask, (__force int)f)) 339 continue; 340 w = snd_pcm_format_width(f); 341 if (w >= width) 342 badness = w - width; 343 else 344 badness = width - w + 32; 345 badness += snd_pcm_format_unsigned(f) != unsignd; 346 badness += snd_pcm_format_big_endian(f) != big; 347 if (badness < best) { 348 best_format = f; 349 best = badness; 350 } 351 } 352 if ((__force int)best_format >= 0) 353 return best_format; 354 else 355 return (__force snd_pcm_format_t)-EINVAL; 356 } else { 357 switch (format) { 358 case SNDRV_PCM_FORMAT_MU_LAW: 359 for (i = 0; i < ARRAY_SIZE(preferred_formats); ++i) { 360 snd_pcm_format_t format1 = preferred_formats[i]; 361 if (snd_mask_test(format_mask, (__force int)format1)) 362 return format1; 363 } 364 /* fall through */ 365 default: 366 return (__force snd_pcm_format_t)-EINVAL; 367 } 368 } 369 } 370 371 int snd_pcm_plug_format_plugins(struct snd_pcm_substream *plug, 372 struct snd_pcm_hw_params *params, 373 struct snd_pcm_hw_params *slave_params) 374 { 375 struct snd_pcm_plugin_format tmpformat; 376 struct snd_pcm_plugin_format dstformat; 377 struct snd_pcm_plugin_format srcformat; 378 snd_pcm_access_t src_access, dst_access; 379 struct snd_pcm_plugin *plugin = NULL; 380 int err; 381 int stream = snd_pcm_plug_stream(plug); 382 int slave_interleaved = (params_channels(slave_params) == 1 || 383 params_access(slave_params) == SNDRV_PCM_ACCESS_RW_INTERLEAVED); 384 385 switch (stream) { 386 case SNDRV_PCM_STREAM_PLAYBACK: 387 dstformat.format = params_format(slave_params); 388 dstformat.rate = params_rate(slave_params); 389 dstformat.channels = params_channels(slave_params); 390 srcformat.format = params_format(params); 391 srcformat.rate = params_rate(params); 392 srcformat.channels = params_channels(params); 393 src_access = SNDRV_PCM_ACCESS_RW_INTERLEAVED; 394 dst_access = (slave_interleaved ? SNDRV_PCM_ACCESS_RW_INTERLEAVED : 395 SNDRV_PCM_ACCESS_RW_NONINTERLEAVED); 396 break; 397 case SNDRV_PCM_STREAM_CAPTURE: 398 dstformat.format = params_format(params); 399 dstformat.rate = params_rate(params); 400 dstformat.channels = params_channels(params); 401 srcformat.format = params_format(slave_params); 402 srcformat.rate = params_rate(slave_params); 403 srcformat.channels = params_channels(slave_params); 404 src_access = (slave_interleaved ? SNDRV_PCM_ACCESS_RW_INTERLEAVED : 405 SNDRV_PCM_ACCESS_RW_NONINTERLEAVED); 406 dst_access = SNDRV_PCM_ACCESS_RW_INTERLEAVED; 407 break; 408 default: 409 snd_BUG(); 410 return -EINVAL; 411 } 412 tmpformat = srcformat; 413 414 pdprintf("srcformat: format=%i, rate=%i, channels=%i\n", 415 srcformat.format, 416 srcformat.rate, 417 srcformat.channels); 418 pdprintf("dstformat: format=%i, rate=%i, channels=%i\n", 419 dstformat.format, 420 dstformat.rate, 421 dstformat.channels); 422 423 /* Format change (linearization) */ 424 if (! rate_match(srcformat.rate, dstformat.rate) && 425 ! snd_pcm_format_linear(srcformat.format)) { 426 if (srcformat.format != SNDRV_PCM_FORMAT_MU_LAW) 427 return -EINVAL; 428 tmpformat.format = SNDRV_PCM_FORMAT_S16; 429 err = snd_pcm_plugin_build_mulaw(plug, 430 &srcformat, &tmpformat, 431 &plugin); 432 if (err < 0) 433 return err; 434 err = snd_pcm_plugin_append(plugin); 435 if (err < 0) { 436 snd_pcm_plugin_free(plugin); 437 return err; 438 } 439 srcformat = tmpformat; 440 src_access = dst_access; 441 } 442 443 /* channels reduction */ 444 if (srcformat.channels > dstformat.channels) { 445 tmpformat.channels = dstformat.channels; 446 err = snd_pcm_plugin_build_route(plug, &srcformat, &tmpformat, &plugin); 447 pdprintf("channels reduction: src=%i, dst=%i returns %i\n", srcformat.channels, tmpformat.channels, err); 448 if (err < 0) 449 return err; 450 err = snd_pcm_plugin_append(plugin); 451 if (err < 0) { 452 snd_pcm_plugin_free(plugin); 453 return err; 454 } 455 srcformat = tmpformat; 456 src_access = dst_access; 457 } 458 459 /* rate resampling */ 460 if (!rate_match(srcformat.rate, dstformat.rate)) { 461 if (srcformat.format != SNDRV_PCM_FORMAT_S16) { 462 /* convert to S16 for resampling */ 463 tmpformat.format = SNDRV_PCM_FORMAT_S16; 464 err = snd_pcm_plugin_build_linear(plug, 465 &srcformat, &tmpformat, 466 &plugin); 467 if (err < 0) 468 return err; 469 err = snd_pcm_plugin_append(plugin); 470 if (err < 0) { 471 snd_pcm_plugin_free(plugin); 472 return err; 473 } 474 srcformat = tmpformat; 475 src_access = dst_access; 476 } 477 tmpformat.rate = dstformat.rate; 478 err = snd_pcm_plugin_build_rate(plug, 479 &srcformat, &tmpformat, 480 &plugin); 481 pdprintf("rate down resampling: src=%i, dst=%i returns %i\n", srcformat.rate, tmpformat.rate, err); 482 if (err < 0) 483 return err; 484 err = snd_pcm_plugin_append(plugin); 485 if (err < 0) { 486 snd_pcm_plugin_free(plugin); 487 return err; 488 } 489 srcformat = tmpformat; 490 src_access = dst_access; 491 } 492 493 /* format change */ 494 if (srcformat.format != dstformat.format) { 495 tmpformat.format = dstformat.format; 496 if (srcformat.format == SNDRV_PCM_FORMAT_MU_LAW || 497 tmpformat.format == SNDRV_PCM_FORMAT_MU_LAW) { 498 err = snd_pcm_plugin_build_mulaw(plug, 499 &srcformat, &tmpformat, 500 &plugin); 501 } 502 else if (snd_pcm_format_linear(srcformat.format) && 503 snd_pcm_format_linear(tmpformat.format)) { 504 err = snd_pcm_plugin_build_linear(plug, 505 &srcformat, &tmpformat, 506 &plugin); 507 } 508 else 509 return -EINVAL; 510 pdprintf("format change: src=%i, dst=%i returns %i\n", srcformat.format, tmpformat.format, err); 511 if (err < 0) 512 return err; 513 err = snd_pcm_plugin_append(plugin); 514 if (err < 0) { 515 snd_pcm_plugin_free(plugin); 516 return err; 517 } 518 srcformat = tmpformat; 519 src_access = dst_access; 520 } 521 522 /* channels extension */ 523 if (srcformat.channels < dstformat.channels) { 524 tmpformat.channels = dstformat.channels; 525 err = snd_pcm_plugin_build_route(plug, &srcformat, &tmpformat, &plugin); 526 pdprintf("channels extension: src=%i, dst=%i returns %i\n", srcformat.channels, tmpformat.channels, err); 527 if (err < 0) 528 return err; 529 err = snd_pcm_plugin_append(plugin); 530 if (err < 0) { 531 snd_pcm_plugin_free(plugin); 532 return err; 533 } 534 srcformat = tmpformat; 535 src_access = dst_access; 536 } 537 538 /* de-interleave */ 539 if (src_access != dst_access) { 540 err = snd_pcm_plugin_build_copy(plug, 541 &srcformat, 542 &tmpformat, 543 &plugin); 544 pdprintf("interleave change (copy: returns %i)\n", err); 545 if (err < 0) 546 return err; 547 err = snd_pcm_plugin_append(plugin); 548 if (err < 0) { 549 snd_pcm_plugin_free(plugin); 550 return err; 551 } 552 } 553 554 return 0; 555 } 556 557 snd_pcm_sframes_t snd_pcm_plug_client_channels_buf(struct snd_pcm_substream *plug, 558 char *buf, 559 snd_pcm_uframes_t count, 560 struct snd_pcm_plugin_channel **channels) 561 { 562 struct snd_pcm_plugin *plugin; 563 struct snd_pcm_plugin_channel *v; 564 struct snd_pcm_plugin_format *format; 565 int width, nchannels, channel; 566 int stream = snd_pcm_plug_stream(plug); 567 568 if (snd_BUG_ON(!buf)) 569 return -ENXIO; 570 if (stream == SNDRV_PCM_STREAM_PLAYBACK) { 571 plugin = snd_pcm_plug_first(plug); 572 format = &plugin->src_format; 573 } else { 574 plugin = snd_pcm_plug_last(plug); 575 format = &plugin->dst_format; 576 } 577 v = plugin->buf_channels; 578 *channels = v; 579 if ((width = snd_pcm_format_physical_width(format->format)) < 0) 580 return width; 581 nchannels = format->channels; 582 if (snd_BUG_ON(plugin->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED && 583 format->channels > 1)) 584 return -ENXIO; 585 for (channel = 0; channel < nchannels; channel++, v++) { 586 v->frames = count; 587 v->enabled = 1; 588 v->wanted = (stream == SNDRV_PCM_STREAM_CAPTURE); 589 v->area.addr = buf; 590 v->area.first = channel * width; 591 v->area.step = nchannels * width; 592 } 593 return count; 594 } 595 596 snd_pcm_sframes_t snd_pcm_plug_write_transfer(struct snd_pcm_substream *plug, struct snd_pcm_plugin_channel *src_channels, snd_pcm_uframes_t size) 597 { 598 struct snd_pcm_plugin *plugin, *next; 599 struct snd_pcm_plugin_channel *dst_channels; 600 int err; 601 snd_pcm_sframes_t frames = size; 602 603 plugin = snd_pcm_plug_first(plug); 604 while (plugin) { 605 if (frames <= 0) 606 return frames; 607 if ((next = plugin->next) != NULL) { 608 snd_pcm_sframes_t frames1 = frames; 609 if (plugin->dst_frames) { 610 frames1 = plugin->dst_frames(plugin, frames); 611 if (frames1 <= 0) 612 return frames1; 613 } 614 if ((err = next->client_channels(next, frames1, &dst_channels)) < 0) { 615 return err; 616 } 617 if (err != frames1) { 618 frames = err; 619 if (plugin->src_frames) { 620 frames = plugin->src_frames(plugin, frames1); 621 if (frames <= 0) 622 return frames; 623 } 624 } 625 } else 626 dst_channels = NULL; 627 pdprintf("write plugin: %s, %li\n", plugin->name, frames); 628 if ((frames = plugin->transfer(plugin, src_channels, dst_channels, frames)) < 0) 629 return frames; 630 src_channels = dst_channels; 631 plugin = next; 632 } 633 return snd_pcm_plug_client_size(plug, frames); 634 } 635 636 snd_pcm_sframes_t snd_pcm_plug_read_transfer(struct snd_pcm_substream *plug, struct snd_pcm_plugin_channel *dst_channels_final, snd_pcm_uframes_t size) 637 { 638 struct snd_pcm_plugin *plugin, *next; 639 struct snd_pcm_plugin_channel *src_channels, *dst_channels; 640 snd_pcm_sframes_t frames = size; 641 int err; 642 643 frames = snd_pcm_plug_slave_size(plug, frames); 644 if (frames < 0) 645 return frames; 646 647 src_channels = NULL; 648 plugin = snd_pcm_plug_first(plug); 649 while (plugin && frames > 0) { 650 if ((next = plugin->next) != NULL) { 651 if ((err = plugin->client_channels(plugin, frames, &dst_channels)) < 0) { 652 return err; 653 } 654 frames = err; 655 } else { 656 dst_channels = dst_channels_final; 657 } 658 pdprintf("read plugin: %s, %li\n", plugin->name, frames); 659 if ((frames = plugin->transfer(plugin, src_channels, dst_channels, frames)) < 0) 660 return frames; 661 plugin = next; 662 src_channels = dst_channels; 663 } 664 return frames; 665 } 666 667 int snd_pcm_area_silence(const struct snd_pcm_channel_area *dst_area, size_t dst_offset, 668 size_t samples, snd_pcm_format_t format) 669 { 670 /* FIXME: sub byte resolution and odd dst_offset */ 671 unsigned char *dst; 672 unsigned int dst_step; 673 int width; 674 const unsigned char *silence; 675 if (!dst_area->addr) 676 return 0; 677 dst = dst_area->addr + (dst_area->first + dst_area->step * dst_offset) / 8; 678 width = snd_pcm_format_physical_width(format); 679 if (width <= 0) 680 return -EINVAL; 681 if (dst_area->step == (unsigned int) width && width >= 8) 682 return snd_pcm_format_set_silence(format, dst, samples); 683 silence = snd_pcm_format_silence_64(format); 684 if (! silence) 685 return -EINVAL; 686 dst_step = dst_area->step / 8; 687 if (width == 4) { 688 /* Ima ADPCM */ 689 int dstbit = dst_area->first % 8; 690 int dstbit_step = dst_area->step % 8; 691 while (samples-- > 0) { 692 if (dstbit) 693 *dst &= 0xf0; 694 else 695 *dst &= 0x0f; 696 dst += dst_step; 697 dstbit += dstbit_step; 698 if (dstbit == 8) { 699 dst++; 700 dstbit = 0; 701 } 702 } 703 } else { 704 width /= 8; 705 while (samples-- > 0) { 706 memcpy(dst, silence, width); 707 dst += dst_step; 708 } 709 } 710 return 0; 711 } 712 713 int snd_pcm_area_copy(const struct snd_pcm_channel_area *src_area, size_t src_offset, 714 const struct snd_pcm_channel_area *dst_area, size_t dst_offset, 715 size_t samples, snd_pcm_format_t format) 716 { 717 /* FIXME: sub byte resolution and odd dst_offset */ 718 char *src, *dst; 719 int width; 720 int src_step, dst_step; 721 src = src_area->addr + (src_area->first + src_area->step * src_offset) / 8; 722 if (!src_area->addr) 723 return snd_pcm_area_silence(dst_area, dst_offset, samples, format); 724 dst = dst_area->addr + (dst_area->first + dst_area->step * dst_offset) / 8; 725 if (!dst_area->addr) 726 return 0; 727 width = snd_pcm_format_physical_width(format); 728 if (width <= 0) 729 return -EINVAL; 730 if (src_area->step == (unsigned int) width && 731 dst_area->step == (unsigned int) width && width >= 8) { 732 size_t bytes = samples * width / 8; 733 memcpy(dst, src, bytes); 734 return 0; 735 } 736 src_step = src_area->step / 8; 737 dst_step = dst_area->step / 8; 738 if (width == 4) { 739 /* Ima ADPCM */ 740 int srcbit = src_area->first % 8; 741 int srcbit_step = src_area->step % 8; 742 int dstbit = dst_area->first % 8; 743 int dstbit_step = dst_area->step % 8; 744 while (samples-- > 0) { 745 unsigned char srcval; 746 if (srcbit) 747 srcval = *src & 0x0f; 748 else 749 srcval = (*src & 0xf0) >> 4; 750 if (dstbit) 751 *dst = (*dst & 0xf0) | srcval; 752 else 753 *dst = (*dst & 0x0f) | (srcval << 4); 754 src += src_step; 755 srcbit += srcbit_step; 756 if (srcbit == 8) { 757 src++; 758 srcbit = 0; 759 } 760 dst += dst_step; 761 dstbit += dstbit_step; 762 if (dstbit == 8) { 763 dst++; 764 dstbit = 0; 765 } 766 } 767 } else { 768 width /= 8; 769 while (samples-- > 0) { 770 memcpy(dst, src, width); 771 src += src_step; 772 dst += dst_step; 773 } 774 } 775 return 0; 776 } 777