src/pcm/pcm_plug.c

   1 /*
   2  * \file pcm/pcm_plug.c
   3  * \ingroup PCM_Plugins
   4  * \brief PCM Route & Volume Plugin Interface
   5  * \author Abramo Bagnara <abramo@alsa-project.org>
   6  * \date 2000-2001
   7  */
   8 /*
   9  *  PCM - Plug
  10  *  Copyright (c) 2000 by Abramo Bagnara <abramo@alsa-project.org>
  11  *
  12  *
  13  *   This library is free software; you can redistribute it and/or modify
  14  *   it under the terms of the GNU Lesser General Public License as
  15  *   published by the Free Software Foundation; either version 2.1 of
  16  *   the License, or (at your option) any later version.
  17  *
  18  *   This program is distributed in the hope that it will be useful,
  19  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  *   GNU Lesser General Public License for more details.
  22  *
  23  *   You should have received a copy of the GNU Lesser General Public
  24  *   License along with this library; if not, write to the Free Software
  25  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  26  *
  27  */
  28
  29 #include "pcm_local.h"
  30 #include "pcm_plugin.h"
  31
  32 #ifndef PIC
  33 /* entry for static linking */
  34 const char *_snd_module_pcm_plug = "";
  35 #endif
  36
  37 #ifndef DOC_HIDDEN
  38
  39 enum snd_pcm_plug_route_policy {
  40         PLUG_ROUTE_POLICY_NONE,
  41         PLUG_ROUTE_POLICY_DEFAULT,
  42         PLUG_ROUTE_POLICY_COPY,
  43         PLUG_ROUTE_POLICY_AVERAGE,
  44         PLUG_ROUTE_POLICY_DUP,
  45 };
  46
  47 typedef struct {
  48         snd_pcm_generic_t gen;
  49         snd_pcm_t *req_slave;
  50         snd_pcm_format_t sformat;
  51         int schannels;
  52         int srate;
  53         const snd_config_t *rate_converter;
  54         enum snd_pcm_plug_route_policy route_policy;
  55         snd_pcm_route_ttable_entry_t *ttable;
  56         int ttable_ok, ttable_last;
  57         unsigned int tt_ssize, tt_cused, tt_sused;
  58 } snd_pcm_plug_t;
  59
  60 #endif
  61
  62 static int snd_pcm_plug_close(snd_pcm_t *pcm)
  63 {
  64         snd_pcm_plug_t *plug = pcm->private_data;
  65         int err, result = 0;
  66         free(plug->ttable);
  67         assert(plug->gen.slave == plug->req_slave);
  68         if (plug->gen.close_slave) {
  69                 snd_pcm_unlink_hw_ptr(pcm, plug->req_slave);
  70                 snd_pcm_unlink_appl_ptr(pcm, plug->req_slave);
  71                 err = snd_pcm_close(plug->req_slave);
  72                 if (err < 0)
  73                         result = err;
  74         }
  75         free(plug);
  76         return result;
  77 }
  78
  79 static int snd_pcm_plug_info(snd_pcm_t *pcm, snd_pcm_info_t *info)
  80 {
  81         snd_pcm_plug_t *plug = pcm->private_data;
  82         snd_pcm_t *slave = plug->req_slave;
  83         int err;
  84
  85         if ((err = snd_pcm_info(slave, info)) < 0)
  86                 return err;
  87         return 0;
  88 }
  89
  90 static const snd_pcm_format_t linear_preferred_formats[] = {
  91 #ifdef SND_LITTLE_ENDIAN
  92         SND_PCM_FORMAT_S16_LE,
  93         SND_PCM_FORMAT_U16_LE,
  94         SND_PCM_FORMAT_S16_BE,
  95         SND_PCM_FORMAT_U16_BE,
  96 #else
  97         SND_PCM_FORMAT_S16_BE,
  98         SND_PCM_FORMAT_U16_BE,
  99         SND_PCM_FORMAT_S16_LE,
 100         SND_PCM_FORMAT_U16_LE,
 101 #endif
 102 #ifdef SND_LITTLE_ENDIAN
 103         SND_PCM_FORMAT_S32_LE,
 104         SND_PCM_FORMAT_U32_LE,
 105         SND_PCM_FORMAT_S32_BE,
 106         SND_PCM_FORMAT_U32_BE,
 107 #else
 108         SND_PCM_FORMAT_S32_BE,
 109         SND_PCM_FORMAT_U32_BE,
 110         SND_PCM_FORMAT_S32_LE,
 111         SND_PCM_FORMAT_U32_LE,
 112 #endif
 113         SND_PCM_FORMAT_S8,
 114         SND_PCM_FORMAT_U8,
 115 #ifdef SND_LITTLE_ENDIAN
 116         SND_PCM_FORMAT_FLOAT_LE,
 117         SND_PCM_FORMAT_FLOAT64_LE,
 118         SND_PCM_FORMAT_FLOAT_BE,
 119         SND_PCM_FORMAT_FLOAT64_BE,
 120 #else
 121         SND_PCM_FORMAT_FLOAT_BE,
 122         SND_PCM_FORMAT_FLOAT64_BE,
 123         SND_PCM_FORMAT_FLOAT_LE,
 124         SND_PCM_FORMAT_FLOAT64_LE,
 125 #endif
 126 #ifdef SND_LITTLE_ENDIAN
 127         SND_PCM_FORMAT_S24_LE,
 128         SND_PCM_FORMAT_U24_LE,
 129         SND_PCM_FORMAT_S24_BE,
 130         SND_PCM_FORMAT_U24_BE,
 131 #else
 132         SND_PCM_FORMAT_S24_BE,
 133         SND_PCM_FORMAT_U24_BE,
 134         SND_PCM_FORMAT_S24_LE,
 135         SND_PCM_FORMAT_U24_LE,
 136 #endif
 137 #ifdef SND_LITTLE_ENDIAN
 138         SND_PCM_FORMAT_S24_3LE,
 139         SND_PCM_FORMAT_U24_3LE,
 140         SND_PCM_FORMAT_S24_3BE,
 141         SND_PCM_FORMAT_U24_3BE,
 142 #else
 143         SND_PCM_FORMAT_S24_3BE,
 144         SND_PCM_FORMAT_U24_3BE,
 145         SND_PCM_FORMAT_S24_3LE,
 146         SND_PCM_FORMAT_U24_3LE,
 147 #endif
 148 #ifdef SND_LITTLE_ENDIAN
 149         SND_PCM_FORMAT_S20_3LE,
 150         SND_PCM_FORMAT_U20_3LE,
 151         SND_PCM_FORMAT_S20_3BE,
 152         SND_PCM_FORMAT_U20_3BE,
 153 #else
 154         SND_PCM_FORMAT_S20_3BE,
 155         SND_PCM_FORMAT_U20_3BE,
 156         SND_PCM_FORMAT_S20_3LE,
 157         SND_PCM_FORMAT_U20_3LE,
 158 #endif
 159 #ifdef SND_LITTLE_ENDIAN
 160         SND_PCM_FORMAT_S18_3LE,
 161         SND_PCM_FORMAT_U18_3LE,
 162         SND_PCM_FORMAT_S18_3BE,
 163         SND_PCM_FORMAT_U18_3BE,
 164 #else
 165         SND_PCM_FORMAT_S18_3BE,
 166         SND_PCM_FORMAT_U18_3BE,
 167         SND_PCM_FORMAT_S18_3LE,
 168         SND_PCM_FORMAT_U18_3LE,
 169 #endif
 170 };
 171
 172 #if defined(BUILD_PCM_PLUGIN_MULAW) || \
 173         defined(BUILD_PCM_PLUGIN_ALAW) || \
 174         defined(BUILD_PCM_PLUGIN_ADPCM)
 175 #define BUILD_PCM_NONLINEAR
 176 #endif
 177
 178 #ifdef BUILD_PCM_NONLINEAR
 179 static const snd_pcm_format_t nonlinear_preferred_formats[] = {
 180 #ifdef BUILD_PCM_PLUGIN_MULAW
 181         SND_PCM_FORMAT_MU_LAW,
 182 #endif
 183 #ifdef BUILD_PCM_PLUGIN_ALAW
 184         SND_PCM_FORMAT_A_LAW,
 185 #endif
 186 #ifdef BUILD_PCM_PLUGIN_ADPCM
 187         SND_PCM_FORMAT_IMA_ADPCM,
 188 #endif
 189 };
 190 #endif
 191
 192 #ifdef BUILD_PCM_PLUGIN_LFLOAT
 193 static const snd_pcm_format_t float_preferred_formats[] = {
 194 #ifdef SND_LITTLE_ENDIAN
 195         SND_PCM_FORMAT_FLOAT_LE,
 196         SND_PCM_FORMAT_FLOAT64_LE,
 197         SND_PCM_FORMAT_FLOAT_BE,
 198         SND_PCM_FORMAT_FLOAT64_BE,
 199 #else
 200         SND_PCM_FORMAT_FLOAT_BE,
 201         SND_PCM_FORMAT_FLOAT64_BE,
 202         SND_PCM_FORMAT_FLOAT_LE,
 203         SND_PCM_FORMAT_FLOAT64_LE,
 204 #endif
 205 };
 206 #endif
 207
 208 static const char linear_format_widths[32] = {
 209         0, 0, 0, 0, 0, 0, 0, 1,
 210         0, 0, 0, 0, 0, 0, 0, 1,
 211         0, 1, 0, 1, 0, 0, 0, 1,
 212         0, 0, 0, 0, 0, 0, 0, 1,
 213 };
 214
 215 static int check_linear_format(const snd_pcm_format_mask_t *format_mask, int wid, int sgn, int ed)
 216 {
 217         int e, s;
 218         if (! linear_format_widths[wid - 1])
 219                 return SND_PCM_FORMAT_UNKNOWN;
 220         for (e = 0; e < 2; e++) {
 221                 for (s = 0; s < 2; s++) {
 222                         int pw = ((wid + 7) / 8) * 8;
 223                         for (; pw <= 32; pw += 8) {
 224                                 snd_pcm_format_t f;
 225                                 f = snd_pcm_build_linear_format(wid, pw, sgn, ed);
 226                                 if (f != SND_PCM_FORMAT_UNKNOWN &&
 227                                     snd_pcm_format_mask_test(format_mask, f))
 228                                         return f;
 229                         }
 230                         sgn = !sgn;
 231                 }
 232                 ed = !ed;
 233         }
 234         return SND_PCM_FORMAT_UNKNOWN;
 235 }
 236
 237 static snd_pcm_format_t snd_pcm_plug_slave_format(snd_pcm_format_t format, const snd_pcm_format_mask_t *format_mask)
 238 {
 239         int w, w1, u, e;
 240         snd_pcm_format_t f;
 241         snd_pcm_format_mask_t lin = { SND_PCM_FMTBIT_LINEAR };
 242         snd_pcm_format_mask_t fl = {
 243 #ifdef BUILD_PCM_PLUGIN_LFLOAT
 244                 SND_PCM_FMTBIT_FLOAT
 245 #else
 246                 { 0 }
 247 #endif
 248         };
 249         if (snd_pcm_format_mask_test(format_mask, format))
 250                 return format;
 251         if (!snd_pcm_format_mask_test(&lin, format) &&
 252             !snd_pcm_format_mask_test(&fl, format)) {
 253                 unsigned int i;
 254                 switch (format) {
 255 #ifdef BUILD_PCM_PLUGIN_MULAW
 256                 case SND_PCM_FORMAT_MU_LAW:
 257 #endif
 258 #ifdef BUILD_PCM_PLUGIN_ALAW
 259                 case SND_PCM_FORMAT_A_LAW:
 260 #endif
 261 #ifdef BUILD_PCM_PLUGIN_ADPCM
 262                 case SND_PCM_FORMAT_IMA_ADPCM:
 263 #endif
 264                         for (i = 0; i < sizeof(linear_preferred_formats) / sizeof(linear_preferred_formats[0]); ++i) {
 265                                 snd_pcm_format_t f = linear_preferred_formats[i];
 266                                 if (snd_pcm_format_mask_test(format_mask, f))
 267                                         return f;
 268                         }
 269                         /* Fall through */
 270                 default:
 271                         return SND_PCM_FORMAT_UNKNOWN;
 272                 }
 273
 274         }
 275         snd_mask_intersect(&lin, format_mask);
 276         snd_mask_intersect(&fl, format_mask);
 277         if (snd_mask_empty(&lin) && snd_mask_empty(&fl)) {
 278 #ifdef BUILD_PCM_NONLINEAR
 279                 unsigned int i;
 280                 for (i = 0; i < sizeof(nonlinear_preferred_formats) / sizeof(nonlinear_preferred_formats[0]); ++i) {
 281                         snd_pcm_format_t f = nonlinear_preferred_formats[i];
 282                         if (snd_pcm_format_mask_test(format_mask, f))
 283                                 return f;
 284                 }
 285 #endif
 286                 return SND_PCM_FORMAT_UNKNOWN;
 287         }
 288 #ifdef BUILD_PCM_PLUGIN_LFLOAT
 289         if (snd_pcm_format_float(format)) {
 290                 if (snd_pcm_format_mask_test(&fl, format)) {
 291                         unsigned int i;
 292                         for (i = 0; i < sizeof(float_preferred_formats) / sizeof(float_preferred_formats[0]); ++i) {
 293                                 snd_pcm_format_t f = float_preferred_formats[i];
 294                                 if (snd_pcm_format_mask_test(format_mask, f))
 295                                         return f;
 296                         }
 297                 }
 298                 w = 32;
 299                 u = 0;
 300                 e = snd_pcm_format_big_endian(format);
 301         } else
 302 #endif
 303         if (snd_mask_empty(&lin)) {
 304 #ifdef BUILD_PCM_PLUGIN_LFLOAT
 305                 unsigned int i;
 306                 for (i = 0; i < sizeof(float_preferred_formats) / sizeof(float_preferred_formats[0]); ++i) {
 307                         snd_pcm_format_t f = float_preferred_formats[i];
 308                         if (snd_pcm_format_mask_test(format_mask, f))
 309                                 return f;
 310                 }
 311 #endif
 312                 return SND_PCM_FORMAT_UNKNOWN;
 313         } else {
 314                 w = snd_pcm_format_width(format);
 315                 u = snd_pcm_format_unsigned(format);
 316                 e = snd_pcm_format_big_endian(format);
 317         }
 318         for (w1 = w; w1 <= 32; w1++) {
 319                 f = check_linear_format(format_mask, w1, u, e);
 320                 if (f != SND_PCM_FORMAT_UNKNOWN)
 321                         return f;
 322         }
 323         for (w1 = w - 1; w1 > 0; w1--) {
 324                 f = check_linear_format(format_mask, w1, u, e);
 325                 if (f != SND_PCM_FORMAT_UNKNOWN)
 326                         return f;
 327         }
 328         return SND_PCM_FORMAT_UNKNOWN;
 329 }
 330
 331 static void snd_pcm_plug_clear(snd_pcm_t *pcm)
 332 {
 333         snd_pcm_plug_t *plug = pcm->private_data;
 334         snd_pcm_t *slave = plug->req_slave;
 335         /* Clear old plugins */
 336         if (plug->gen.slave != slave) {
 337                 snd_pcm_unlink_hw_ptr(pcm, plug->gen.slave);
 338                 snd_pcm_unlink_appl_ptr(pcm, plug->gen.slave);
 339                 snd_pcm_close(plug->gen.slave);
 340                 plug->gen.slave = slave;
 341                 pcm->fast_ops = slave->fast_ops;
 342                 pcm->fast_op_arg = slave->fast_op_arg;
 343         }
 344 }
 345
 346 #ifndef DOC_HIDDEN
 347 typedef struct {
 348         snd_pcm_access_t access;
 349         snd_pcm_format_t format;
 350         unsigned int channels;
 351         unsigned int rate;
 352 } snd_pcm_plug_params_t;
 353 #endif
 354
 355 #ifdef BUILD_PCM_PLUGIN_RATE
 356 static int snd_pcm_plug_change_rate(snd_pcm_t *pcm, snd_pcm_t **new, snd_pcm_plug_params_t *clt, snd_pcm_plug_params_t *slv)
 357 {
 358         snd_pcm_plug_t *plug = pcm->private_data;
 359         int err;
 360         if (clt->rate == slv->rate)
 361                 return 0;
 362         assert(snd_pcm_format_linear(slv->format));
 363         err = snd_pcm_rate_open(new, NULL, slv->format, slv->rate, plug->rate_converter,
 364                                 plug->gen.slave, plug->gen.slave != plug->req_slave);
 365         if (err < 0)
 366                 return err;
 367         slv->access = clt->access;
 368         slv->rate = clt->rate;
 369         if (snd_pcm_format_linear(clt->format))
 370                 slv->format = clt->format;
 371         return 1;
 372 }
 373 #endif
 374
 375 #ifdef BUILD_PCM_PLUGIN_ROUTE
 376 static int snd_pcm_plug_change_channels(snd_pcm_t *pcm, snd_pcm_t **new, snd_pcm_plug_params_t *clt, snd_pcm_plug_params_t *slv)
 377 {
 378         snd_pcm_plug_t *plug = pcm->private_data;
 379         unsigned int tt_ssize, tt_cused, tt_sused;
 380         snd_pcm_route_ttable_entry_t *ttable;
 381         int err;
 382         if (clt->channels == slv->channels &&
 383             (!plug->ttable || !plug->ttable_last))
 384                 return 0;
 385         if (clt->rate != slv->rate &&
 386             clt->channels > slv->channels)
 387                 return 0;
 388         assert(snd_pcm_format_linear(slv->format));
 389         tt_ssize = slv->channels;
 390         tt_cused = clt->channels;
 391         tt_sused = slv->channels;
 392         ttable = alloca(tt_cused * tt_sused * sizeof(*ttable));
 393         if (plug->ttable) {     /* expand or shrink table */
 394                 unsigned int c = 0, s = 0;
 395                 for (c = 0; c < tt_cused; c++) {
 396                         for (s = 0; s < tt_sused; s++) {
 397                                 snd_pcm_route_ttable_entry_t v;
 398                                 if (c >= plug->tt_cused)
 399                                         v = 0;
 400                                 else if (s >= plug->tt_sused)
 401                                         v = 0;
 402                                 else
 403                                         v = plug->ttable[c * plug->tt_ssize + s];
 404                                 ttable[c * tt_ssize + s] = v;
 405                         }
 406                 }
 407                 plug->ttable_ok = 1;
 408         } else {
 409                 unsigned int k;
 410                 unsigned int c = 0, s = 0;
 411                 enum snd_pcm_plug_route_policy rpolicy = plug->route_policy;
 412                 int n;
 413                 for (k = 0; k < tt_cused * tt_sused; ++k)
 414                         ttable[k] = 0;
 415                 if (rpolicy == PLUG_ROUTE_POLICY_DEFAULT) {
 416                         rpolicy = PLUG_ROUTE_POLICY_COPY;
 417                         /* it's hack for mono conversion */
 418                         if (clt->channels == 1 || slv->channels == 1)
 419                                 rpolicy = PLUG_ROUTE_POLICY_AVERAGE;
 420                 }
 421                 switch (rpolicy) {
 422                 case PLUG_ROUTE_POLICY_AVERAGE:
 423                 case PLUG_ROUTE_POLICY_DUP:
 424                         if (clt->channels > slv->channels) {
 425                                 n = clt->channels;
 426                         } else {
 427                                 n = slv->channels;
 428                         }
 429                         while (n-- > 0) {
 430                                 snd_pcm_route_ttable_entry_t v = SND_PCM_PLUGIN_ROUTE_FULL;
 431                                 if (rpolicy == PLUG_ROUTE_POLICY_AVERAGE) {
 432                                         if (pcm->stream == SND_PCM_STREAM_PLAYBACK &&
 433                                             clt->channels > slv->channels) {
 434                                                 int srcs = clt->channels / slv->channels;
 435                                                 if (s < clt->channels % slv->channels)
 436                                                         srcs++;
 437                                                 v /= srcs;
 438                                         } else if (pcm->stream == SND_PCM_STREAM_CAPTURE &&
 439                                                    slv->channels > clt->channels) {
 440                                                         int srcs = slv->channels / clt->channels;
 441                                                 if (s < slv->channels % clt->channels)
 442                                                         srcs++;
 443                                                 v /= srcs;
 444                                         }
 445                                 }
 446                                 ttable[c * tt_ssize + s] = v;
 447                                 if (++c == clt->channels)
 448                                         c = 0;
 449                                 if (++s == slv->channels)
 450                                         s = 0;
 451                         }
 452                         break;
 453                 case PLUG_ROUTE_POLICY_COPY:
 454                         if (clt->channels < slv->channels) {
 455                                 n = clt->channels;
 456                         } else {
 457                                 n = slv->channels;
 458                         }
 459                         for (c = 0; (int)c < n; c++)
 460                                 ttable[c * tt_ssize + c] = SND_PCM_PLUGIN_ROUTE_FULL;
 461                         break;
 462                 default:
 463                         SNDERR("Invalid route policy");
 464                         break;
 465                 }
 466         }
 467         err = snd_pcm_route_open(new, NULL, slv->format, (int) slv->channels, ttable, tt_ssize, tt_cused, tt_sused, plug->gen.slave, plug->gen.slave != plug->req_slave);
 468         if (err < 0)
 469                 return err;
 470         slv->channels = clt->channels;
 471         slv->access = clt->access;
 472         if (snd_pcm_format_linear(clt->format))
 473                 slv->format = clt->format;
 474         return 1;
 475 }
 476 #endif
 477
 478 static int snd_pcm_plug_change_format(snd_pcm_t *pcm, snd_pcm_t **new, snd_pcm_plug_params_t *clt, snd_pcm_plug_params_t *slv)
 479 {
 480         snd_pcm_plug_t *plug = pcm->private_data;
 481         int err;
 482         snd_pcm_format_t cfmt;
 483         int (*f)(snd_pcm_t **_pcm, const char *name, snd_pcm_format_t sformat, snd_pcm_t *slave, int close_slave);
 484
 485         /* No conversion is needed */
 486         if (clt->format == slv->format &&
 487             clt->rate == slv->rate &&
 488             clt->channels == clt->channels)
 489                 return 0;
 490
 491         if (snd_pcm_format_linear(slv->format)) {
 492                 /* Conversion is done in another plugin */
 493                 if (clt->rate != slv->rate ||
 494                     clt->channels != slv->channels)
 495                         return 0;
 496                 cfmt = clt->format;
 497                 switch (clt->format) {
 498 #ifdef BUILD_PCM_PLUGIN_MULAW
 499                 case SND_PCM_FORMAT_MU_LAW:
 500                         f = snd_pcm_mulaw_open;
 501                         break;
 502 #endif
 503 #ifdef BUILD_PCM_PLUGIN_ALAW
 504                 case SND_PCM_FORMAT_A_LAW:
 505                         f = snd_pcm_alaw_open;
 506                         break;
 507 #endif
 508 #ifdef BUILD_PCM_PLUGIN_ADPCM
 509                 case SND_PCM_FORMAT_IMA_ADPCM:
 510                         f = snd_pcm_adpcm_open;
 511                         break;
 512 #endif
 513                 default:
 514 #ifdef BUILD_PCM_PLUGIN_LFLOAT
 515                         if (snd_pcm_format_float(clt->format))
 516                                 f = snd_pcm_lfloat_open;
 517
 518                         else
 519 #endif
 520                                 f = snd_pcm_linear_open;
 521                         break;
 522                 }
 523 #ifdef BUILD_PCM_PLUGIN_LFLOAT
 524         } else if (snd_pcm_format_float(slv->format)) {
 525                 /* Conversion is done in another plugin */
 526                 if (clt->format == slv->format &&
 527                     clt->rate == slv->rate &&
 528                     clt->channels == slv->channels)
 529                         return 0;
 530                 cfmt = clt->format;
 531                 if (snd_pcm_format_linear(clt->format))
 532                         f = snd_pcm_lfloat_open;
 533                 else
 534                         return -EINVAL;
 535 #endif
 536 #ifdef BUILD_PCM_NONLINEAR
 537         } else {
 538                 switch (slv->format) {
 539 #ifdef BUILD_PCM_PLUGIN_MULAW
 540                 case SND_PCM_FORMAT_MU_LAW:
 541                         f = snd_pcm_mulaw_open;
 542                         break;
 543 #endif
 544 #ifdef BUILD_PCM_PLUGIN_ALAW
 545                 case SND_PCM_FORMAT_A_LAW:
 546                         f = snd_pcm_alaw_open;
 547                         break;
 548 #endif
 549 #ifdef BUILD_PCM_PLUGIN_ADPCM
 550                 case SND_PCM_FORMAT_IMA_ADPCM:
 551                         f = snd_pcm_adpcm_open;
 552                         break;
 553 #endif
 554                 default:
 555                         return -EINVAL;
 556                 }
 557                 if (snd_pcm_format_linear(clt->format))
 558                         cfmt = clt->format;
 559                 else
 560                         cfmt = SND_PCM_FORMAT_S16;
 561 #endif /* NONLINEAR */
 562         }
 563         err = f(new, NULL, slv->format, plug->gen.slave, plug->gen.slave != plug->req_slave);
 564         if (err < 0)
 565                 return err;
 566         slv->format = cfmt;
 567         slv->access = clt->access;
 568         return 1;
 569 }
 570
 571 static int snd_pcm_plug_change_access(snd_pcm_t *pcm, snd_pcm_t **new, snd_pcm_plug_params_t *clt, snd_pcm_plug_params_t *slv)
 572 {
 573         snd_pcm_plug_t *plug = pcm->private_data;
 574         int err;
 575         if (clt->access == slv->access)
 576                 return 0;
 577         err = snd_pcm_copy_open(new, NULL, plug->gen.slave, plug->gen.slave != plug->req_slave);
 578         if (err < 0)
 579                 return err;
 580         slv->access = clt->access;
 581         return 1;
 582 }
 583
 584 #ifdef BUILD_PCM_PLUGIN_MMAP_EMUL
 585 static int snd_pcm_plug_change_mmap(snd_pcm_t *pcm, snd_pcm_t **new,
 586                                     snd_pcm_plug_params_t *clt,
 587                                     snd_pcm_plug_params_t *slv)
 588 {
 589         snd_pcm_plug_t *plug = pcm->private_data;
 590         int err;
 591
 592         if (clt->access == slv->access)
 593                 return 0;
 594
 595         switch (slv->access) {
 596         case SND_PCM_ACCESS_MMAP_INTERLEAVED:
 597         case SND_PCM_ACCESS_MMAP_NONINTERLEAVED:
 598         case SND_PCM_ACCESS_MMAP_COMPLEX:
 599                 return 0;
 600         default:
 601                 break;
 602         }
 603
 604         err = __snd_pcm_mmap_emul_open(new, NULL, plug->gen.slave,
 605                                        plug->gen.slave != plug->req_slave);
 606         if (err < 0)
 607                 return err;
 608         slv->access = clt->access;
 609         return 1;
 610 }
 611 #endif
 612
 613 static int snd_pcm_plug_insert_plugins(snd_pcm_t *pcm,
 614                                        snd_pcm_plug_params_t *client,
 615                                        snd_pcm_plug_params_t *slave)
 616 {
 617         snd_pcm_plug_t *plug = pcm->private_data;
 618         static int (*const funcs[])(snd_pcm_t *_pcm, snd_pcm_t **new, snd_pcm_plug_params_t *s, snd_pcm_plug_params_t *d) = {
 619 #ifdef BUILD_PCM_PLUGIN_MMAP_EMUL
 620                 snd_pcm_plug_change_mmap,
 621 #endif
 622                 snd_pcm_plug_change_format,
 623 #ifdef BUILD_PCM_PLUGIN_ROUTE
 624                 snd_pcm_plug_change_channels,
 625 #endif
 626 #ifdef BUILD_PCM_PLUGIN_RATE
 627                 snd_pcm_plug_change_rate,
 628 #endif
 629 #ifdef BUILD_PCM_PLUGIN_ROUTE
 630                 snd_pcm_plug_change_channels,
 631 #endif
 632                 snd_pcm_plug_change_format,
 633                 snd_pcm_plug_change_access
 634         };
 635         snd_pcm_plug_params_t p = *slave;
 636         unsigned int k = 0;
 637         plug->ttable_ok = plug->ttable_last = 0;
 638         while (client->format != p.format ||
 639                client->channels != p.channels ||
 640                client->rate != p.rate ||
 641                client->access != p.access) {
 642                 snd_pcm_t *new;
 643                 int err;
 644                 if (k >= sizeof(funcs)/sizeof(*funcs))
 645                         return -EINVAL;
 646                 err = funcs[k](pcm, &new, client, &p);
 647                 if (err < 0) {
 648                         snd_pcm_plug_clear(pcm);
 649                         return err;
 650                 }
 651                 if (err) {
 652                         plug->gen.slave = new;
 653                         pcm->fast_ops = new->fast_ops;
 654                         pcm->fast_op_arg = new->fast_op_arg;
 655                 }
 656                 k++;
 657         }
 658 #ifdef BUILD_PCM_PLUGIN_ROUTE
 659         /* it's exception, user specified ttable, but no reduction/expand */
 660         if (plug->ttable && !plug->ttable_ok) {
 661                 snd_pcm_t *new;
 662                 int err;
 663                 plug->ttable_last = 1;
 664                 err = snd_pcm_plug_change_channels(pcm, &new, client, &p);
 665                 if (err < 0) {
 666                         snd_pcm_plug_clear(pcm);
 667                         return err;
 668                 }
 669                 assert(err);
 670                 assert(plug->ttable_ok);
 671                 plug->gen.slave = new;
 672                 pcm->fast_ops = new->fast_ops;
 673                 pcm->fast_op_arg = new->fast_op_arg;
 674         }
 675 #endif
 676         return 0;
 677 }
 678
 679 static int snd_pcm_plug_hw_refine_cprepare(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *params)
 680 {
 681         unsigned int rate_min, channels_max;
 682         int err;
 683
 684         /* HACK: to avoid overflow in PARTBIT_RATE code */
 685         err = snd_pcm_hw_param_get_min(params, SND_PCM_HW_PARAM_RATE, &rate_min, NULL);
 686         if (err < 0)
 687                 return err;
 688         if (rate_min < 4000) {
 689                 _snd_pcm_hw_param_set_min(params, SND_PCM_HW_PARAM_RATE, 4000, 0);
 690                 if (snd_pcm_hw_param_empty(params, SND_PCM_HW_PARAM_RATE))
 691                         return -EINVAL;
 692         }
 693         /* HACK: to avoid overflow in PERIOD_SIZE code */
 694         err = snd_pcm_hw_param_get_max(params, SND_PCM_HW_PARAM_CHANNELS, &channels_max, NULL);
 695         if (err < 0)
 696                 return err;
 697         if (channels_max > 10000) {
 698                 _snd_pcm_hw_param_set_max(params, SND_PCM_HW_PARAM_CHANNELS, 10000, 0);
 699                 if (snd_pcm_hw_param_empty(params, SND_PCM_HW_PARAM_CHANNELS))
 700                         return -EINVAL;
 701         }
 702         return 0;
 703 }
 704
 705 static int snd_pcm_plug_hw_refine_sprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *sparams)
 706 {
 707         snd_pcm_plug_t *plug = pcm->private_data;
 708         int err;
 709
 710         _snd_pcm_hw_params_any(sparams);
 711         if (plug->sformat >= 0) {
 712                 _snd_pcm_hw_params_set_format(sparams, plug->sformat);
 713                 _snd_pcm_hw_params_set_subformat(sparams, SND_PCM_SUBFORMAT_STD);
 714         }
 715         if (plug->schannels > 0)
 716                 _snd_pcm_hw_param_set(sparams, SND_PCM_HW_PARAM_CHANNELS,
 717                                       plug->schannels, 0);
 718         if (plug->srate > 0)
 719                 _snd_pcm_hw_param_set_minmax(sparams, SND_PCM_HW_PARAM_RATE,
 720                                               plug->srate, 0, plug->srate + 1, -1);
 721         /* reduce the available configurations */
 722         err = snd_pcm_hw_refine(plug->req_slave, sparams);
 723         if (err < 0)
 724                 return err;
 725         return 0;
 726 }
 727
 728 static int check_access_change(snd_pcm_hw_params_t *cparams,
 729                                snd_pcm_hw_params_t *sparams)
 730 {
 731         snd_pcm_access_mask_t *smask;
 732 #ifdef BUILD_PCM_PLUGIN_MMAP_EMUL
 733         const snd_pcm_access_mask_t *cmask;
 734         snd_pcm_access_mask_t mask;
 735 #endif
 736
 737         smask = (snd_pcm_access_mask_t *)
 738                 snd_pcm_hw_param_get_mask(sparams,
 739                                           SND_PCM_HW_PARAM_ACCESS);
 740         if (snd_pcm_access_mask_test(smask, SND_PCM_ACCESS_MMAP_INTERLEAVED) ||
 741             snd_pcm_access_mask_test(smask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED) ||
 742             snd_pcm_access_mask_test(smask, SND_PCM_ACCESS_MMAP_COMPLEX))
 743                 return 0; /* OK, we have mmap support */
 744 #ifdef BUILD_PCM_PLUGIN_MMAP_EMUL
 745         /* no mmap support - we need mmap emulation */
 746         cmask = (const snd_pcm_access_mask_t *)
 747                 snd_pcm_hw_param_get_mask(cparams,
 748                                           SND_PCM_HW_PARAM_ACCESS);
 749         snd_mask_none(&mask);
 750         if (snd_pcm_access_mask_test(cmask, SND_PCM_ACCESS_RW_INTERLEAVED) ||
 751             snd_pcm_access_mask_test(cmask, SND_PCM_ACCESS_MMAP_INTERLEAVED))
 752                 snd_pcm_access_mask_set(&mask,
 753                                         SND_PCM_ACCESS_RW_INTERLEAVED);
 754         if (snd_pcm_access_mask_test(cmask, SND_PCM_ACCESS_RW_NONINTERLEAVED) ||
 755             snd_pcm_access_mask_test(cmask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED))
 756                 snd_pcm_access_mask_set(&mask,
 757                                         SND_PCM_ACCESS_RW_NONINTERLEAVED);
 758         *smask = mask;
 759         return 0;
 760 #else
 761         return -EINVAL;
 762 #endif
 763 }
 764
 765 static int snd_pcm_plug_hw_refine_schange(snd_pcm_t *pcm, snd_pcm_hw_params_t *params,
 766                                           snd_pcm_hw_params_t *sparams)
 767 {
 768         snd_pcm_plug_t *plug = pcm->private_data;
 769         snd_pcm_t *slave = plug->req_slave;
 770         unsigned int links = (SND_PCM_HW_PARBIT_PERIOD_TIME |
 771                               SND_PCM_HW_PARBIT_TICK_TIME);
 772         const snd_pcm_format_mask_t *format_mask, *sformat_mask;
 773         snd_pcm_format_mask_t sfmt_mask;
 774         int err;
 775         snd_pcm_format_t format;
 776         snd_interval_t t, buffer_size;
 777         const snd_interval_t *srate, *crate;
 778
 779         if (plug->srate == -2 ||
 780             (pcm->mode & SND_PCM_NO_AUTO_RESAMPLE) ||
 781             (params->flags & SND_PCM_HW_PARAMS_NORESAMPLE))
 782                 links |= SND_PCM_HW_PARBIT_RATE;
 783         else {
 784                 err = snd_pcm_hw_param_refine_multiple(slave, sparams, SND_PCM_HW_PARAM_RATE, params);
 785                 if (err < 0)
 786                         return err;
 787         }
 788
 789         if (plug->schannels == -2 || (pcm->mode & SND_PCM_NO_AUTO_CHANNELS))
 790                 links |= SND_PCM_HW_PARBIT_CHANNELS;
 791         else {
 792                 err = snd_pcm_hw_param_refine_near(slave, sparams, SND_PCM_HW_PARAM_CHANNELS, params);
 793                 if (err < 0)
 794                         return err;
 795         }
 796         if (plug->sformat == -2 || (pcm->mode & SND_PCM_NO_AUTO_FORMAT))
 797                 links |= SND_PCM_HW_PARBIT_FORMAT;
 798         else {
 799                 format_mask = snd_pcm_hw_param_get_mask(params, SND_PCM_HW_PARAM_FORMAT);
 800                 sformat_mask = snd_pcm_hw_param_get_mask(sparams, SND_PCM_HW_PARAM_FORMAT);
 801                 snd_mask_none(&sfmt_mask);
 802                 for (format = 0; format <= SND_PCM_FORMAT_LAST; format++) {
 803                         snd_pcm_format_t f;
 804                         if (!snd_pcm_format_mask_test(format_mask, format))
 805                                 continue;
 806                         if (snd_pcm_format_mask_test(sformat_mask, format))
 807                                 f = format;
 808                         else {
 809                                 f = snd_pcm_plug_slave_format(format, sformat_mask);
 810                                 if (f == SND_PCM_FORMAT_UNKNOWN)
 811                                         continue;
 812                         }
 813                         snd_pcm_format_mask_set(&sfmt_mask, f);
 814                 }
 815
 816                 if (snd_pcm_format_mask_empty(&sfmt_mask)) {
 817                         SNDERR("Unable to find an usable slave format for '%s'", pcm->name);
 818                         for (format = 0; format <= SND_PCM_FORMAT_LAST; format++) {
 819                                 if (!snd_pcm_format_mask_test(format_mask, format))
 820                                         continue;
 821                                 SNDERR("Format: %s", snd_pcm_format_name(format));
 822                         }
 823                         for (format = 0; format <= SND_PCM_FORMAT_LAST; format++) {
 824                                 if (!snd_pcm_format_mask_test(sformat_mask, format))
 825                                         continue;
 826                                 SNDERR("Slave format: %s", snd_pcm_format_name(format));
 827                         }
 828                         return -EINVAL;
 829                 }
 830                 err = snd_pcm_hw_param_set_mask(slave, sparams, SND_CHANGE,
 831                                                 SND_PCM_HW_PARAM_FORMAT, &sfmt_mask);
 832                 if (err < 0)
 833                         return -EINVAL;
 834         }
 835
 836         if (snd_pcm_hw_param_never_eq(params, SND_PCM_HW_PARAM_ACCESS, sparams)) {
 837                 err = check_access_change(params, sparams);
 838                 if (err < 0) {
 839                         SNDERR("Unable to find an usable access for '%s'",
 840                                pcm->name);
 841                         return err;
 842                 }
 843         }
 844
 845         if ((links & SND_PCM_HW_PARBIT_RATE) ||
 846             snd_pcm_hw_param_always_eq(params, SND_PCM_HW_PARAM_RATE, sparams))
 847                 links |= (SND_PCM_HW_PARBIT_PERIOD_SIZE |
 848                           SND_PCM_HW_PARBIT_BUFFER_SIZE);
 849         else {
 850                 snd_interval_copy(&buffer_size, snd_pcm_hw_param_get_interval(params, SND_PCM_HW_PARAM_BUFFER_SIZE));
 851                 snd_interval_unfloor(&buffer_size);
 852                 crate = snd_pcm_hw_param_get_interval(params, SND_PCM_HW_PARAM_RATE);
 853                 srate = snd_pcm_hw_param_get_interval(sparams, SND_PCM_HW_PARAM_RATE);
 854                 snd_interval_muldiv(&buffer_size, srate, crate, &t);
 855                 err = _snd_pcm_hw_param_set_interval(sparams, SND_PCM_HW_PARAM_BUFFER_SIZE, &t);
 856                 if (err < 0)
 857                         return err;
 858         }
 859         err = _snd_pcm_hw_params_refine(sparams, links, params);
 860         if (err < 0)
 861                 return err;
 862         return 0;
 863 }
 864
 865 static int snd_pcm_plug_hw_refine_cchange(snd_pcm_t *pcm ATTRIBUTE_UNUSED,
 866                                           snd_pcm_hw_params_t *params,
 867                                           snd_pcm_hw_params_t *sparams)
 868 {
 869         snd_pcm_plug_t *plug = pcm->private_data;
 870         unsigned int links = (SND_PCM_HW_PARBIT_PERIOD_TIME |
 871                               SND_PCM_HW_PARBIT_TICK_TIME);
 872         const snd_pcm_format_mask_t *format_mask, *sformat_mask;
 873         snd_pcm_format_mask_t fmt_mask;
 874         int err;
 875         snd_pcm_format_t format;
 876         snd_interval_t t;
 877         const snd_interval_t *sbuffer_size;
 878         const snd_interval_t *srate, *crate;
 879
 880         if (plug->schannels == -2 || (pcm->mode & SND_PCM_NO_AUTO_CHANNELS))
 881                 links |= SND_PCM_HW_PARBIT_CHANNELS;
 882
 883         if (plug->sformat == -2 || (pcm->mode & SND_PCM_NO_AUTO_FORMAT))
 884                 links |= SND_PCM_HW_PARBIT_FORMAT;
 885         else {
 886                 format_mask = snd_pcm_hw_param_get_mask(params,
 887                                                         SND_PCM_HW_PARAM_FORMAT);
 888                 sformat_mask = snd_pcm_hw_param_get_mask(sparams,
 889                                                          SND_PCM_HW_PARAM_FORMAT);
 890                 snd_mask_none(&fmt_mask);
 891                 for (format = 0; format <= SND_PCM_FORMAT_LAST; format++) {
 892                         snd_pcm_format_t f;
 893                         if (!snd_pcm_format_mask_test(format_mask, format))
 894                                 continue;
 895                         if (snd_pcm_format_mask_test(sformat_mask, format))
 896                                 f = format;
 897                         else {
 898                                 f = snd_pcm_plug_slave_format(format, sformat_mask);
 899                                 if (f == SND_PCM_FORMAT_UNKNOWN)
 900                                         continue;
 901                         }
 902                         snd_pcm_format_mask_set(&fmt_mask, format);
 903                 }
 904
 905                 if (snd_pcm_format_mask_empty(&fmt_mask)) {
 906                         SNDERR("Unable to find an usable client format");
 907                         for (format = 0; format <= SND_PCM_FORMAT_LAST; format++) {
 908                                 if (!snd_pcm_format_mask_test(format_mask, format))
 909                                         continue;
 910                                 SNDERR("Format: %s", snd_pcm_format_name(format));
 911                         }
 912                         for (format = 0; format <= SND_PCM_FORMAT_LAST; format++) {
 913                                 if (!snd_pcm_format_mask_test(sformat_mask, format))
 914                                         continue;
 915                                 SNDERR("Slave format: %s", snd_pcm_format_name(format));
 916                         }
 917                         return -EINVAL;
 918                 }
 919
 920                 err = _snd_pcm_hw_param_set_mask(params,
 921                                                  SND_PCM_HW_PARAM_FORMAT, &fmt_mask);
 922                 if (err < 0)
 923                         return err;
 924         }
 925
 926         if (plug->srate == -2 ||
 927             (pcm->mode & SND_PCM_NO_AUTO_RESAMPLE) ||
 928             (params->flags & SND_PCM_HW_PARAMS_NORESAMPLE))
 929                 links |= SND_PCM_HW_PARBIT_RATE;
 930         else {
 931                 unsigned int rate_min, srate_min;
 932                 int rate_mindir, srate_mindir;
 933
 934                 /* This is a temporary hack, waiting for a better solution */
 935                 err = snd_pcm_hw_param_get_min(params, SND_PCM_HW_PARAM_RATE, &rate_min, &rate_mindir);
 936                 if (err < 0)
 937                         return err;
 938                 err = snd_pcm_hw_param_get_min(sparams, SND_PCM_HW_PARAM_RATE, &srate_min, &srate_mindir);
 939                 if (err < 0)
 940                         return err;
 941                 if (rate_min == srate_min && srate_mindir > rate_mindir) {
 942                         err = _snd_pcm_hw_param_set_min(params, SND_PCM_HW_PARAM_RATE, srate_min, srate_mindir);
 943                         if (err < 0)
 944                                 return err;
 945                 }
 946         }
 947         if ((links & SND_PCM_HW_PARBIT_RATE) ||
 948             snd_pcm_hw_param_always_eq(params, SND_PCM_HW_PARAM_RATE, sparams))
 949                 links |= (SND_PCM_HW_PARBIT_PERIOD_SIZE |
 950                           SND_PCM_HW_PARBIT_BUFFER_SIZE);
 951         else {
 952                 sbuffer_size = snd_pcm_hw_param_get_interval(sparams, SND_PCM_HW_PARAM_BUFFER_SIZE);
 953                 crate = snd_pcm_hw_param_get_interval(params, SND_PCM_HW_PARAM_RATE);
 954                 srate = snd_pcm_hw_param_get_interval(sparams, SND_PCM_HW_PARAM_RATE);
 955                 snd_interval_muldiv(sbuffer_size, crate, srate, &t);
 956                 snd_interval_floor(&t);
 957                 if (snd_interval_empty(&t))
 958                         return -EINVAL;
 959                 err = _snd_pcm_hw_param_set_interval(params, SND_PCM_HW_PARAM_BUFFER_SIZE, &t);
 960                 if (err < 0)
 961                         return err;
 962         }
 963         err = _snd_pcm_hw_params_refine(params, links, sparams);
 964         if (err < 0)
 965                 return err;
 966         /* FIXME */
 967         params->info &= ~(SND_PCM_INFO_MMAP | SND_PCM_INFO_MMAP_VALID);
 968         return 0;
 969 }
 970
 971 static int snd_pcm_plug_hw_refine_slave(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
 972 {
 973         snd_pcm_plug_t *plug = pcm->private_data;
 974         return snd_pcm_hw_refine(plug->req_slave, params);
 975 }
 976
 977 static int snd_pcm_plug_hw_refine(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
 978 {
 979         return snd_pcm_hw_refine_slave(pcm, params,
 980                                        snd_pcm_plug_hw_refine_cprepare,
 981                                        snd_pcm_plug_hw_refine_cchange,
 982                                        snd_pcm_plug_hw_refine_sprepare,
 983                                        snd_pcm_plug_hw_refine_schange,
 984                                        snd_pcm_plug_hw_refine_slave);
 985 }
 986
 987 static int snd_pcm_plug_hw_params(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
 988 {
 989         snd_pcm_plug_t *plug = pcm->private_data;
 990         snd_pcm_t *slave = plug->req_slave;
 991         snd_pcm_plug_params_t clt_params, slv_params;
 992         snd_pcm_hw_params_t sparams;
 993         int err;
 994
 995         err = snd_pcm_plug_hw_refine_sprepare(pcm, &sparams);
 996         if (err < 0)
 997                 return err;
 998         err = snd_pcm_plug_hw_refine_schange(pcm, params, &sparams);
 999         if (err < 0)
1000                 return err;
1001         err = snd_pcm_hw_refine_soft(slave, &sparams);
1002         if (err < 0)
1003                 return err;
1004
1005         INTERNAL(snd_pcm_hw_params_get_access)(params, &clt_params.access);
1006         INTERNAL(snd_pcm_hw_params_get_format)(params, &clt_params.format);
1007         INTERNAL(snd_pcm_hw_params_get_channels)(params, &clt_params.channels);
1008         INTERNAL(snd_pcm_hw_params_get_rate)(params, &clt_params.rate, 0);
1009
1010         INTERNAL(snd_pcm_hw_params_get_format)(&sparams, &slv_params.format);
1011         INTERNAL(snd_pcm_hw_params_get_channels)(&sparams, &slv_params.channels);
1012         INTERNAL(snd_pcm_hw_params_get_rate)(&sparams, &slv_params.rate, 0);
1013         snd_pcm_plug_clear(pcm);
1014         if (!(clt_params.format == slv_params.format &&
1015               clt_params.channels == slv_params.channels &&
1016               clt_params.rate == slv_params.rate &&
1017               !plug->ttable &&
1018               snd_pcm_hw_params_test_access(slave, &sparams,
1019                                             clt_params.access) >= 0)) {
1020                 INTERNAL(snd_pcm_hw_params_set_access_first)(slave, &sparams, &slv_params.access);
1021                 err = snd_pcm_plug_insert_plugins(pcm, &clt_params, &slv_params);
1022                 if (err < 0)
1023                         return err;
1024         }
1025         slave = plug->gen.slave;
1026         err = _snd_pcm_hw_params(slave, params);
1027         if (err < 0) {
1028                 snd_pcm_plug_clear(pcm);
1029                 return err;
1030         }
1031         snd_pcm_unlink_hw_ptr(pcm, plug->req_slave);
1032         snd_pcm_unlink_appl_ptr(pcm, plug->req_slave);
1033         snd_pcm_link_hw_ptr(pcm, slave);
1034         snd_pcm_link_appl_ptr(pcm, slave);
1035         return 0;
1036 }
1037
1038 static int snd_pcm_plug_hw_free(snd_pcm_t *pcm)
1039 {
1040         snd_pcm_plug_t *plug = pcm->private_data;
1041         snd_pcm_t *slave = plug->gen.slave;
1042         int err = snd_pcm_hw_free(slave);
1043         snd_pcm_plug_clear(pcm);
1044         return err;
1045 }
1046
1047 static void snd_pcm_plug_dump(snd_pcm_t *pcm, snd_output_t *out)
1048 {
1049         snd_pcm_plug_t *plug = pcm->private_data;
1050         snd_output_printf(out, "Plug PCM: ");
1051         snd_pcm_dump(plug->gen.slave, out);
1052 }
1053
1054 static const snd_pcm_ops_t snd_pcm_plug_ops = {
1055         .close = snd_pcm_plug_close,
1056         .info = snd_pcm_plug_info,
1057         .hw_refine = snd_pcm_plug_hw_refine,
1058         .hw_params = snd_pcm_plug_hw_params,
1059         .hw_free = snd_pcm_plug_hw_free,
1060         .sw_params = snd_pcm_generic_sw_params,
1061         .channel_info = snd_pcm_generic_channel_info,
1062         .dump = snd_pcm_plug_dump,
1063         .nonblock = snd_pcm_generic_nonblock,
1064         .async = snd_pcm_generic_async,
1065         .mmap = snd_pcm_generic_mmap,
1066         .munmap = snd_pcm_generic_munmap,
1067 };
1068
1069 /**
1070  * \brief Creates a new Plug PCM
1071  * \param pcmp Returns created PCM handle
1072  * \param name Name of PCM
1073  * \param sformat Slave (destination) format
1074  * \param slave Slave PCM handle
1075  * \param close_slave When set, the slave PCM handle is closed with copy PCM
1076  * \retval zero on success otherwise a negative error code
1077  * \warning Using of this function might be dangerous in the sense
1078  *          of compatibility reasons. The prototype might be freely
1079  *          changed in future.
1080  */
1081 int snd_pcm_plug_open(snd_pcm_t **pcmp,
1082                       const char *name,
1083                       snd_pcm_format_t sformat, int schannels, int srate,
1084                       const snd_config_t *rate_converter,
1085                       enum snd_pcm_plug_route_policy route_policy,
1086                       snd_pcm_route_ttable_entry_t *ttable,
1087                       unsigned int tt_ssize,
1088                       unsigned int tt_cused, unsigned int tt_sused,
1089                       snd_pcm_t *slave, int close_slave)
1090 {
1091         snd_pcm_t *pcm;
1092         snd_pcm_plug_t *plug;
1093         int err;
1094         assert(pcmp && slave);
1095
1096         plug = calloc(1, sizeof(snd_pcm_plug_t));
1097         if (!plug)
1098                 return -ENOMEM;
1099         plug->sformat = sformat;
1100         plug->schannels = schannels;
1101         plug->srate = srate;
1102         plug->rate_converter = rate_converter;
1103         plug->gen.slave = plug->req_slave = slave;
1104         plug->gen.close_slave = close_slave;
1105         plug->route_policy = route_policy;
1106         plug->ttable = ttable;
1107         plug->tt_ssize = tt_ssize;
1108         plug->tt_cused = tt_cused;
1109         plug->tt_sused = tt_sused;
1110
1111         err = snd_pcm_new(&pcm, SND_PCM_TYPE_PLUG, name, slave->stream, slave->mode);
1112         if (err < 0) {
1113                 free(plug);
1114                 return err;
1115         }
1116         pcm->ops = &snd_pcm_plug_ops;
1117         pcm->fast_ops = slave->fast_ops;
1118         pcm->fast_op_arg = slave->fast_op_arg;
1119         pcm->private_data = plug;
1120         pcm->poll_fd = slave->poll_fd;
1121         pcm->poll_events = slave->poll_events;
1122         pcm->mmap_shadow = 1;
1123         pcm->monotonic = slave->monotonic;
1124         snd_pcm_link_hw_ptr(pcm, slave);
1125         snd_pcm_link_appl_ptr(pcm, slave);
1126         *pcmp = pcm;
1127
1128         return 0;
1129 }
1130
1131 /*! \page pcm_plugins
1132
1133 \section pcm_plugins_plug Automatic conversion plugin
1134
1135 This plugin converts channels, rate and format on request.
1136
1137 \code
1138 pcm.name {
1139         type plug               # Automatic conversion PCM
1140         slave STR               # Slave name
1141         # or
1142         slave {                 # Slave definition
1143                 pcm STR         # Slave PCM name
1144                 # or
1145                 pcm { }         # Slave PCM definition
1146                 [format STR]    # Slave format (default nearest) or "unchanged"
1147                 [channels INT]  # Slave channels (default nearest) or "unchanged"
1148                 [rate INT]      # Slave rate (default nearest) or "unchanged"
1149         }
1150         route_policy STR        # route policy for automatic ttable generation
1151                                 # STR can be 'default', 'average', 'copy', 'duplicate'
1152                                 # average: result is average of input channels
1153                                 # copy: only first channels are copied to destination
1154                                 # duplicate: duplicate first set of channels
1155                                 # default: copy policy, except for mono capture - sum
1156         ttable {                # Transfer table (bi-dimensional compound of cchannels * schannels numbers)
1157                 CCHANNEL {
1158                         SCHANNEL REAL   # route value (0.0 - 1.0)
1159                 }
1160         }
1161         rate_converter STR      # type of rate converter
1162         # or
1163         rate_converter [ STR1 STR2 ... ]
1164                                 # type of rate converter
1165                                 # default value is taken from defaults.pcm.rate_converter
1166 }
1167 \endcode
1168
1169 \subsection pcm_plugins_plug_funcref Function reference
1170
1171 <UL>
1172   <LI>snd_pcm_plug_open()
1173   <LI>_snd_pcm_plug_open()
1174 </UL>
1175
1176 */
1177
1178 /**
1179  * \brief Creates a new Plug PCM
1180  * \param pcmp Returns created PCM handle
1181  * \param name Name of PCM
1182  * \param root Root configuration node
1183  * \param conf Configuration node with Plug PCM description
1184  * \param stream Stream type
1185  * \param mode Stream mode
1186  * \retval zero on success otherwise a negative error code
1187  * \warning Using of this function might be dangerous in the sense
1188  *          of compatibility reasons. The prototype might be freely
1189  *          changed in future.
1190  */
1191 int _snd_pcm_plug_open(snd_pcm_t **pcmp, const char *name,
1192                        snd_config_t *root, snd_config_t *conf,
1193                        snd_pcm_stream_t stream, int mode)
1194 {
1195         snd_config_iterator_t i, next;
1196         int err;
1197         snd_pcm_t *spcm;
1198         snd_config_t *slave = NULL, *sconf;
1199         snd_config_t *tt = NULL;
1200         enum snd_pcm_plug_route_policy route_policy = PLUG_ROUTE_POLICY_DEFAULT;
1201         snd_pcm_route_ttable_entry_t *ttable = NULL;
1202         unsigned int csize, ssize;
1203         unsigned int cused, sused;
1204         snd_pcm_format_t sformat = SND_PCM_FORMAT_UNKNOWN;
1205         int schannels = -1, srate = -1;
1206         const snd_config_t *rate_converter = NULL;
1207
1208         snd_config_for_each(i, next, conf) {
1209                 snd_config_t *n = snd_config_iterator_entry(i);
1210                 const char *id;
1211                 if (snd_config_get_id(n, &id) < 0)
1212                         continue;
1213                 if (snd_pcm_conf_generic_id(id))
1214                         continue;
1215                 if (strcmp(id, "slave") == 0) {
1216                         slave = n;
1217                         continue;
1218                 }
1219 #ifdef BUILD_PCM_PLUGIN_ROUTE
1220                 if (strcmp(id, "ttable") == 0) {
1221                         route_policy = PLUG_ROUTE_POLICY_NONE;
1222                         if (snd_config_get_type(n) != SND_CONFIG_TYPE_COMPOUND) {
1223                                 SNDERR("Invalid type for %s", id);
1224                                 return -EINVAL;
1225                         }
1226                         tt = n;
1227                         continue;
1228                 }
1229                 if (strcmp(id, "route_policy") == 0) {
1230                         const char *str;
1231                         if ((err = snd_config_get_string(n, &str)) < 0) {
1232                                 SNDERR("Invalid type for %s", id);
1233                                 return -EINVAL;
1234                         }
1235                         if (tt != NULL)
1236                                 SNDERR("Table is defined, route policy is ignored");
1237                         if (!strcmp(str, "default"))
1238                                 route_policy = PLUG_ROUTE_POLICY_DEFAULT;
1239                         else if (!strcmp(str, "average"))
1240                                 route_policy = PLUG_ROUTE_POLICY_AVERAGE;
1241                         else if (!strcmp(str, "copy"))
1242                                 route_policy = PLUG_ROUTE_POLICY_COPY;
1243                         else if (!strcmp(str, "duplicate"))
1244                                 route_policy = PLUG_ROUTE_POLICY_DUP;
1245                         continue;
1246                 }
1247 #endif
1248 #ifdef BUILD_PCM_PLUGIN_RATE
1249                 if (strcmp(id, "rate_converter") == 0) {
1250                         rate_converter = n;
1251                         continue;
1252                 }
1253 #endif
1254                 SNDERR("Unknown field %s", id);
1255                 return -EINVAL;
1256         }
1257         if (!slave) {
1258                 SNDERR("slave is not defined");
1259                 return -EINVAL;
1260         }
1261         err = snd_pcm_slave_conf(root, slave, &sconf, 3,
1262                                  SND_PCM_HW_PARAM_FORMAT, SCONF_UNCHANGED, &sformat,
1263                                  SND_PCM_HW_PARAM_CHANNELS, SCONF_UNCHANGED, &schannels,
1264                                  SND_PCM_HW_PARAM_RATE, SCONF_UNCHANGED, &srate);
1265         if (err < 0)
1266                 return err;
1267 #ifdef BUILD_PCM_PLUGIN_ROUTE
1268         if (tt) {
1269                 err = snd_pcm_route_determine_ttable(tt, &csize, &ssize);
1270                 if (err < 0) {
1271                         snd_config_delete(sconf);
1272                         return err;
1273                 }
1274                 ttable = malloc(csize * ssize * sizeof(*ttable));
1275                 if (ttable == NULL) {
1276                         snd_config_delete(sconf);
1277                         return err;
1278                 }
1279                 err = snd_pcm_route_load_ttable(tt, ttable, csize, ssize, &cused, &sused, -1);
1280                 if (err < 0) {
1281                         snd_config_delete(sconf);
1282                         return err;
1283                 }
1284         }
1285 #endif
1286
1287 #ifdef BUILD_PCM_PLUGIN_RATE
1288         if (! rate_converter)
1289                 rate_converter = snd_pcm_rate_get_default_converter(root);
1290 #endif
1291
1292         err = snd_pcm_open_slave(&spcm, root, sconf, stream, mode, conf);
1293         snd_config_delete(sconf);
1294         if (err < 0)
1295                 return err;
1296         err = snd_pcm_plug_open(pcmp, name, sformat, schannels, srate, rate_converter,
1297                                 route_policy, ttable, ssize, cused, sused, spcm, 1);
1298         if (err < 0)
1299                 snd_pcm_close(spcm);
1300         return err;
1301 }
1302 #ifndef DOC_HIDDEN
1303 SND_DLSYM_BUILD_VERSION(_snd_pcm_plug_open, SND_PCM_DLSYM_VERSION);
1304 #endif