linux/alsa/alsa_driver.c

   1 /* -*- mode: c; c-file-style: "linux"; -*- */
   2 /*
   3     Copyright (C) 2001 Paul Davis
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19 */
  20
  21
  22 #define __STDC_FORMAT_MACROS   // For inttypes.h to work in C++
  23 #define _GNU_SOURCE            /* for strcasestr() from string.h */
  24
  25 #include <math.h>
  26 #include <stdio.h>
  27 #include <memory.h>
  28 #include <unistd.h>
  29 #include <stdlib.h>
  30 #include <errno.h>
  31 #include <stdarg.h>
  32 #include <signal.h>
  33 #include <sys/types.h>
  34 #include <sys/time.h>
  35 #include <string.h>
  36
  37 #include "alsa_driver.h"
  38 #include "hammerfall.h"
  39 #include "hdsp.h"
  40 #include "ice1712.h"
  41 #include "usx2y.h"
  42 #include "generic.h"
  43 #include "memops.h"
  44 #include "JackError.h"
  45
  46 #include "alsa_midi_impl.h"
  47
  48 extern void store_work_time (int);
  49 extern void store_wait_time (int);
  50 extern void show_wait_times ();
  51 extern void show_work_times ();
  52
  53 #undef DEBUG_WAKEUP
  54
  55 char* strcasestr(const char* haystack, const char* needle);
  56
  57 /* Delay (in process calls) before jackd will report an xrun */
  58 #define XRUN_REPORT_DELAY 0
  59
  60 void
  61 jack_driver_init (jack_driver_t *driver)
  62 {
  63     memset (driver, 0, sizeof (*driver));
  64
  65     driver->attach = 0;
  66     driver->detach = 0;
  67     driver->write = 0;
  68     driver->read = 0;
  69     driver->null_cycle = 0;
  70     driver->bufsize = 0;
  71     driver->start = 0;
  72     driver->stop = 0;
  73 }
  74
  75 void
  76 jack_driver_nt_init (jack_driver_nt_t * driver)
  77 {
  78     memset (driver, 0, sizeof (*driver));
  79
  80     jack_driver_init ((jack_driver_t *) driver);
  81
  82     driver->attach = 0;
  83     driver->detach = 0;
  84     driver->bufsize = 0;
  85     driver->stop = 0;
  86     driver->start = 0;
  87
  88     driver->nt_bufsize = 0;
  89     driver->nt_start = 0;
  90     driver->nt_stop = 0;
  91     driver->nt_attach = 0;
  92     driver->nt_detach = 0;
  93     driver->nt_run_cycle = 0;
  94 }
  95
  96 static void
  97 alsa_driver_release_channel_dependent_memory (alsa_driver_t *driver)
  98 {
  99         bitset_destroy (&driver->channels_done);
 100         bitset_destroy (&driver->channels_not_done);
 101
 102         if (driver->playback_addr) {
 103                 free (driver->playback_addr);
 104                 driver->playback_addr = 0;
 105         }
 106
 107         if (driver->capture_addr) {
 108                 free (driver->capture_addr);
 109                 driver->capture_addr = 0;
 110         }
 111
 112         if (driver->playback_interleave_skip) {
 113                 free (driver->playback_interleave_skip);
 114                 driver->playback_interleave_skip = NULL;
 115         }
 116
 117         if (driver->capture_interleave_skip) {
 118                 free (driver->capture_interleave_skip);
 119                 driver->capture_interleave_skip = NULL;
 120         }
 121
 122         if (driver->silent) {
 123                 free (driver->silent);
 124                 driver->silent = 0;
 125         }
 126
 127         if (driver->dither_state) {
 128                 free (driver->dither_state);
 129                 driver->dither_state = 0;
 130         }
 131 }
 132
 133 static int
 134 alsa_driver_check_capabilities (alsa_driver_t *driver)
 135 {
 136         return 0;
 137 }
 138
 139 char* get_control_device_name(const char * device_name);
 140
 141 static int
 142 alsa_driver_check_card_type (alsa_driver_t *driver)
 143 {
 144         int err;
 145         snd_ctl_card_info_t *card_info;
 146         char * ctl_name;
 147
 148         snd_ctl_card_info_alloca (&card_info);
 149
 150         ctl_name = get_control_device_name(driver->alsa_name_playback);
 151
 152         // XXX: I don't know the "right" way to do this. Which to use
 153         // driver->alsa_name_playback or driver->alsa_name_capture.
 154         if ((err = snd_ctl_open (&driver->ctl_handle, ctl_name, 0)) < 0) {
 155                 jack_error ("control open \"%s\" (%s)", ctl_name,
 156                             snd_strerror(err));
 157         } else if ((err = snd_ctl_card_info(driver->ctl_handle, card_info)) < 0) {
 158                 jack_error ("control hardware info \"%s\" (%s)",
 159                             driver->alsa_name_playback, snd_strerror (err));
 160                 snd_ctl_close (driver->ctl_handle);
 161         }
 162
 163         driver->alsa_driver = strdup(snd_ctl_card_info_get_driver (card_info));
 164
 165         free(ctl_name);
 166
 167         return alsa_driver_check_capabilities (driver);
 168 }
 169
 170 static int
 171 alsa_driver_hammerfall_hardware (alsa_driver_t *driver)
 172 {
 173         driver->hw = jack_alsa_hammerfall_hw_new (driver);
 174         return 0;
 175 }
 176
 177 static int
 178 alsa_driver_hdsp_hardware (alsa_driver_t *driver)
 179 {
 180         driver->hw = jack_alsa_hdsp_hw_new (driver);
 181         return 0;
 182 }
 183
 184 static int
 185 alsa_driver_ice1712_hardware (alsa_driver_t *driver)
 186 {
 187         driver->hw = jack_alsa_ice1712_hw_new (driver);
 188         return 0;
 189 }
 190
 191 // JACK2
 192 /*
 193 static int
 194 alsa_driver_usx2y_hardware (alsa_driver_t *driver)
 195 {
 196     driver->hw = jack_alsa_usx2y_hw_new (driver);
 197     return 0;
 198 }
 199 */
 200
 201 static int
 202 alsa_driver_generic_hardware (alsa_driver_t *driver)
 203 {
 204         driver->hw = jack_alsa_generic_hw_new (driver);
 205         return 0;
 206 }
 207
 208 static int
 209 alsa_driver_hw_specific (alsa_driver_t *driver, int hw_monitoring,
 210                          int hw_metering)
 211 {
 212         int err;
 213
 214         if (!strcmp(driver->alsa_driver, "RME9652")) {
 215                 if ((err = alsa_driver_hammerfall_hardware (driver)) != 0) {
 216                         return err;
 217                 }
 218         } else if (!strcmp(driver->alsa_driver, "H-DSP")) {
 219                 if ((err = alsa_driver_hdsp_hardware (driver)) !=0) {
 220                         return err;
 221                 }
 222         } else if (!strcmp(driver->alsa_driver, "ICE1712")) {
 223                 if ((err = alsa_driver_ice1712_hardware (driver)) !=0) {
 224                         return err;
 225                 }
 226         }
 227     // JACK2
 228     /*
 229         else if (!strcmp(driver->alsa_driver, "USB US-X2Y")) {
 230                 if ((err = alsa_driver_usx2y_hardware (driver)) !=0) {
 231                                 return err;
 232                 }
 233         }
 234     */
 235        else {
 236                 if ((err = alsa_driver_generic_hardware (driver)) != 0) {
 237                         return err;
 238                 }
 239         }
 240
 241         if (driver->hw->capabilities & Cap_HardwareMonitoring) {
 242                 driver->has_hw_monitoring = TRUE;
 243                 /* XXX need to ensure that this is really FALSE or
 244                  * TRUE or whatever*/
 245                 driver->hw_monitoring = hw_monitoring;
 246         } else {
 247                 driver->has_hw_monitoring = FALSE;
 248                 driver->hw_monitoring = FALSE;
 249         }
 250
 251         if (driver->hw->capabilities & Cap_ClockLockReporting) {
 252                 driver->has_clock_sync_reporting = TRUE;
 253         } else {
 254                 driver->has_clock_sync_reporting = FALSE;
 255         }
 256
 257         if (driver->hw->capabilities & Cap_HardwareMetering) {
 258                 driver->has_hw_metering = TRUE;
 259                 driver->hw_metering = hw_metering;
 260         } else {
 261                 driver->has_hw_metering = FALSE;
 262                 driver->hw_metering = FALSE;
 263         }
 264
 265         return 0;
 266 }
 267
 268 static void
 269 alsa_driver_setup_io_function_pointers (alsa_driver_t *driver)
 270 {
 271         if (driver->playback_handle) {
 272                 if (SND_PCM_FORMAT_FLOAT_LE == driver->playback_sample_format) {
 273                         driver->write_via_copy = sample_move_dS_floatLE;
 274                 } else {
 275                         switch (driver->playback_sample_bytes) {
 276                         case 2:
 277                                 switch (driver->dither) {
 278                                 case Rectangular:
 279                                         jack_info("Rectangular dithering at 16 bits");
 280                                         driver->write_via_copy = driver->quirk_bswap?
 281                                                 sample_move_dither_rect_d16_sSs:
 282                                                 sample_move_dither_rect_d16_sS;
 283                                         break;
 284
 285                                 case Triangular:
 286                                         jack_info("Triangular dithering at 16 bits");
 287                                         driver->write_via_copy = driver->quirk_bswap?
 288                                                 sample_move_dither_tri_d16_sSs:
 289                                                 sample_move_dither_tri_d16_sS;
 290                                         break;
 291
 292                                 case Shaped:
 293                                         jack_info("Noise-shaped dithering at 16 bits");
 294                                         driver->write_via_copy = driver->quirk_bswap?
 295                                                 sample_move_dither_shaped_d16_sSs:
 296                                                 sample_move_dither_shaped_d16_sS;
 297                                         break;
 298
 299                                 default:
 300                                         driver->write_via_copy = driver->quirk_bswap?
 301                                                 sample_move_d16_sSs :
 302                                                 sample_move_d16_sS;
 303                                         break;
 304                                 }
 305                                 break;
 306
 307                         case 3: /* NO DITHER */
 308                                 driver->write_via_copy = driver->quirk_bswap?
 309                                         sample_move_d24_sSs:
 310                                         sample_move_d24_sS;
 311
 312                                 break;
 313
 314                         case 4: /* NO DITHER */
 315                                 driver->write_via_copy = driver->quirk_bswap?
 316                                         sample_move_d32u24_sSs:
 317                                         sample_move_d32u24_sS;
 318                                 break;
 319
 320                         default:
 321                                 jack_error ("impossible sample width (%d) discovered!",
 322                                                 driver->playback_sample_bytes);
 323                                 exit (1);
 324                         }
 325                 }
 326         }
 327
 328         if (driver->capture_handle) {
 329                 if (SND_PCM_FORMAT_FLOAT_LE == driver->capture_sample_format) {
 330                         driver->read_via_copy = sample_move_floatLE_sSs;
 331                 } else {
 332                         switch (driver->capture_sample_bytes) {
 333                         case 2:
 334                                 driver->read_via_copy = driver->quirk_bswap?
 335                                         sample_move_dS_s16s:
 336                                         sample_move_dS_s16;
 337                                 break;
 338                         case 3:
 339                                 driver->read_via_copy = driver->quirk_bswap?
 340                                         sample_move_dS_s24s:
 341                                         sample_move_dS_s24;
 342                                 break;
 343                         case 4:
 344                                 driver->read_via_copy = driver->quirk_bswap?
 345                                         sample_move_dS_s32u24s:
 346                                         sample_move_dS_s32u24;
 347                                 break;
 348                         }
 349                 }
 350         }
 351 }
 352
 353 static int
 354 alsa_driver_configure_stream (alsa_driver_t *driver, char *device_name,
 355                               const char *stream_name,
 356                               snd_pcm_t *handle,
 357                               snd_pcm_hw_params_t *hw_params,
 358                               snd_pcm_sw_params_t *sw_params,
 359                               unsigned int *nperiodsp,
 360                               channel_t *nchns,
 361                               unsigned long sample_width)
 362 {
 363         int err, format;
 364         unsigned int frame_rate;
 365         snd_pcm_uframes_t stop_th;
 366         static struct {
 367                 char Name[32];
 368                 snd_pcm_format_t format;
 369                 int swapped;
 370         } formats[] = {
 371             {"32bit float little-endian", SND_PCM_FORMAT_FLOAT_LE},
 372                 {"32bit integer little-endian", SND_PCM_FORMAT_S32_LE, IS_LE},
 373                 {"32bit integer big-endian", SND_PCM_FORMAT_S32_BE, IS_BE},
 374                 {"24bit little-endian", SND_PCM_FORMAT_S24_3LE, IS_LE},
 375                 {"24bit big-endian", SND_PCM_FORMAT_S24_3BE, IS_BE},
 376                 {"16bit little-endian", SND_PCM_FORMAT_S16_LE, IS_LE},
 377                 {"16bit big-endian", SND_PCM_FORMAT_S16_BE, IS_BE},
 378         };
 379 #define NUMFORMATS (sizeof(formats)/sizeof(formats[0]))
 380 #define FIRST_16BIT_FORMAT 5
 381
 382         if ((err = snd_pcm_hw_params_any (handle, hw_params)) < 0)  {
 383                 jack_error ("ALSA: no playback configurations available (%s)",
 384                             snd_strerror (err));
 385                 return -1;
 386         }
 387
 388         if ((err = snd_pcm_hw_params_set_periods_integer (handle, hw_params))
 389             < 0) {
 390                 jack_error ("ALSA: cannot restrict period size to integral"
 391                             " value.");
 392                 return -1;
 393         }
 394
 395         if ((err = snd_pcm_hw_params_set_access (handle, hw_params, SND_PCM_ACCESS_MMAP_NONINTERLEAVED)) < 0) {
 396                 if ((err = snd_pcm_hw_params_set_access (handle, hw_params, SND_PCM_ACCESS_MMAP_INTERLEAVED)) < 0) {
 397                         if ((err = snd_pcm_hw_params_set_access (
 398                                      handle, hw_params,
 399                                      SND_PCM_ACCESS_MMAP_COMPLEX)) < 0) {
 400                                 jack_error ("ALSA: mmap-based access is not possible"
 401                                             " for the %s "
 402                                             "stream of this audio interface",
 403                                             stream_name);
 404                                 return -1;
 405                         }
 406                 }
 407         }
 408
 409         format = (sample_width == 4) ? 0 : NUMFORMATS - 1;
 410
 411         while (1) {
 412                 if ((err = snd_pcm_hw_params_set_format (
 413                              handle, hw_params, formats[format].format)) < 0) {
 414
 415                         if ((sample_width == 4
 416                              ? format++ >= NUMFORMATS - 1
 417                              : format-- <= 0)) {
 418                                 jack_error ("Sorry. The audio interface \"%s\""
 419                                             " doesn't support any of the"
 420                                             " hardware sample formats that"
 421                                             " JACK's alsa-driver can use.",
 422                                             device_name);
 423                                 return -1;
 424                         }
 425                 } else {
 426                         if (formats[format].swapped) {
 427                                 driver->quirk_bswap = 1;
 428                         } else {
 429                                 driver->quirk_bswap = 0;
 430                         }
 431                         jack_info ("ALSA: final selected sample format for %s: %s", stream_name, formats[format].Name);
 432                         break;
 433                 }
 434         }
 435
 436         frame_rate = driver->frame_rate ;
 437         err = snd_pcm_hw_params_set_rate_near (handle, hw_params,
 438                                                &frame_rate, NULL) ;
 439         driver->frame_rate = frame_rate ;
 440         if (err < 0) {
 441                 jack_error ("ALSA: cannot set sample/frame rate to %"
 442                             PRIu32 " for %s", driver->frame_rate,
 443                             stream_name);
 444                 return -1;
 445         }
 446         if (!*nchns) {
 447                 /*if not user-specified, try to find the maximum
 448                  * number of channels */
 449                 unsigned int channels_max ;
 450                 err = snd_pcm_hw_params_get_channels_max (hw_params,
 451                                                           &channels_max);
 452                 *nchns = channels_max ;
 453
 454                 if (*nchns > 1024) {
 455
 456                         /* the hapless user is an unwitting victim of
 457                            the "default" ALSA PCM device, which can
 458                            support up to 16 million channels. since
 459                            they can't be bothered to set up a proper
 460                            default device, limit the number of
 461                            channels for them to a sane default.
 462                         */
 463
 464                         jack_error (
 465 "You appear to be using the ALSA software \"plug\" layer, probably\n"
 466 "a result of using the \"default\" ALSA device. This is less\n"
 467 "efficient than it could be. Consider using a hardware device\n"
 468 "instead rather than using the plug layer. Usually the name of the\n"
 469 "hardware device that corresponds to the first sound card is hw:0\n"
 470                                 );
 471                         *nchns = 2;
 472                 }
 473         }
 474
 475         if ((err = snd_pcm_hw_params_set_channels (handle, hw_params,
 476                                                    *nchns)) < 0) {
 477                 jack_error ("ALSA: cannot set channel count to %u for %s",
 478                             *nchns, stream_name);
 479                 return -1;
 480         }
 481
 482         if ((err = snd_pcm_hw_params_set_period_size (handle, hw_params,
 483                                                       driver->frames_per_cycle,
 484                                                       0))
 485             < 0) {
 486                 jack_error ("ALSA: cannot set period size to %" PRIu32
 487                             " frames for %s", driver->frames_per_cycle,
 488                             stream_name);
 489                 return -1;
 490         }
 491
 492         *nperiodsp = driver->user_nperiods;
 493         snd_pcm_hw_params_set_periods_min (handle, hw_params, nperiodsp, NULL);
 494         if (*nperiodsp < driver->user_nperiods)
 495                 *nperiodsp = driver->user_nperiods;
 496         if (snd_pcm_hw_params_set_periods_near (handle, hw_params,
 497                                                 nperiodsp, NULL) < 0) {
 498                 jack_error ("ALSA: cannot set number of periods to %u for %s",
 499                             *nperiodsp, stream_name);
 500                 return -1;
 501         }
 502
 503         if (*nperiodsp < driver->user_nperiods) {
 504                 jack_error ("ALSA: got smaller periods %u than %u for %s",
 505                             *nperiodsp, (unsigned int) driver->user_nperiods,
 506                             stream_name);
 507                 return -1;
 508         }
 509         jack_info ("ALSA: use %d periods for %s", *nperiodsp, stream_name);
 510 #if 0
 511         if (!jack_power_of_two(driver->frames_per_cycle)) {
 512                 jack_error("JACK: frames must be a power of two "
 513                            "(64, 512, 1024, ...)\n");
 514                 return -1;
 515         }
 516 #endif
 517
 518         if ((err = snd_pcm_hw_params_set_buffer_size (handle, hw_params,
 519                                                       *nperiodsp *
 520                                                       driver->frames_per_cycle))
 521             < 0) {
 522                 jack_error ("ALSA: cannot set buffer length to %" PRIu32
 523                             " for %s",
 524                             *nperiodsp * driver->frames_per_cycle,
 525                             stream_name);
 526                 return -1;
 527         }
 528
 529         if ((err = snd_pcm_hw_params (handle, hw_params)) < 0) {
 530                 jack_error ("ALSA: cannot set hardware parameters for %s",
 531                             stream_name);
 532                 return -1;
 533         }
 534
 535         snd_pcm_sw_params_current (handle, sw_params);
 536
 537         if ((err = snd_pcm_sw_params_set_start_threshold (handle, sw_params,
 538                                                           0U)) < 0) {
 539                 jack_error ("ALSA: cannot set start mode for %s", stream_name);
 540                 return -1;
 541         }
 542
 543         stop_th = *nperiodsp * driver->frames_per_cycle;
 544         if (driver->soft_mode) {
 545                 stop_th = (snd_pcm_uframes_t)-1;
 546         }
 547
 548         if ((err = snd_pcm_sw_params_set_stop_threshold (
 549                      handle, sw_params, stop_th)) < 0) {
 550                 jack_error ("ALSA: cannot set stop mode for %s",
 551                             stream_name);
 552                 return -1;
 553         }
 554
 555         if ((err = snd_pcm_sw_params_set_silence_threshold (
 556                      handle, sw_params, 0)) < 0) {
 557                 jack_error ("ALSA: cannot set silence threshold for %s",
 558                             stream_name);
 559                 return -1;
 560         }
 561
 562 #if 0
 563         jack_info ("set silence size to %lu * %lu = %lu",
 564                  driver->frames_per_cycle, *nperiodsp,
 565                  driver->frames_per_cycle * *nperiodsp);
 566
 567         if ((err = snd_pcm_sw_params_set_silence_size (
 568                      handle, sw_params,
 569                      driver->frames_per_cycle * *nperiodsp)) < 0) {
 570                 jack_error ("ALSA: cannot set silence size for %s",
 571                             stream_name);
 572                 return -1;
 573         }
 574 #endif
 575
 576         if (handle == driver->playback_handle)
 577                 err = snd_pcm_sw_params_set_avail_min (
 578                         handle, sw_params,
 579                         driver->frames_per_cycle
 580                         * (*nperiodsp - driver->user_nperiods + 1));
 581         else
 582                 err = snd_pcm_sw_params_set_avail_min (
 583                         handle, sw_params, driver->frames_per_cycle);
 584
 585         if (err < 0) {
 586                 jack_error ("ALSA: cannot set avail min for %s", stream_name);
 587                 return -1;
 588         }
 589
 590         if ((err = snd_pcm_sw_params (handle, sw_params)) < 0) {
 591                 jack_error ("ALSA: cannot set software parameters for %s\n",
 592                             stream_name);
 593                 return -1;
 594         }
 595
 596         return 0;
 597 }
 598
 599 static int
 600 alsa_driver_set_parameters (alsa_driver_t *driver,
 601                             jack_nframes_t frames_per_cycle,
 602                             jack_nframes_t user_nperiods,
 603                             jack_nframes_t rate)
 604 {
 605         int dir;
 606         snd_pcm_uframes_t p_period_size = 0;
 607         snd_pcm_uframes_t c_period_size = 0;
 608         channel_t chn;
 609         unsigned int pr = 0;
 610         unsigned int cr = 0;
 611         int err;
 612
 613         driver->frame_rate = rate;
 614         driver->frames_per_cycle = frames_per_cycle;
 615         driver->user_nperiods = user_nperiods;
 616
 617         jack_info ("configuring for %" PRIu32 "Hz, period = %"
 618                  PRIu32 " frames (%.1f ms), buffer = %" PRIu32 " periods",
 619                  rate, frames_per_cycle, (((float)frames_per_cycle / (float) rate) * 1000.0f), user_nperiods);
 620
 621         if (driver->capture_handle) {
 622                 if (alsa_driver_configure_stream (
 623                             driver,
 624                             driver->alsa_name_capture,
 625                             "capture",
 626                             driver->capture_handle,
 627                             driver->capture_hw_params,
 628                             driver->capture_sw_params,
 629                             &driver->capture_nperiods,
 630                             &driver->capture_nchannels,
 631                             driver->capture_sample_bytes)) {
 632                         jack_error ("ALSA: cannot configure capture channel");
 633                         return -1;
 634                 }
 635         }
 636
 637         if (driver->playback_handle) {
 638                 if (alsa_driver_configure_stream (
 639                             driver,
 640                             driver->alsa_name_playback,
 641                             "playback",
 642                             driver->playback_handle,
 643                             driver->playback_hw_params,
 644                             driver->playback_sw_params,
 645                             &driver->playback_nperiods,
 646                             &driver->playback_nchannels,
 647                             driver->playback_sample_bytes)) {
 648                         jack_error ("ALSA: cannot configure playback channel");
 649                         return -1;
 650                 }
 651         }
 652
 653         /* check the rate, since thats rather important */
 654
 655         if (driver->playback_handle) {
 656                 snd_pcm_hw_params_get_rate (driver->playback_hw_params,
 657                                             &pr, &dir);
 658         }
 659
 660         if (driver->capture_handle) {
 661                 snd_pcm_hw_params_get_rate (driver->capture_hw_params,
 662                                             &cr, &dir);
 663         }
 664
 665         if (driver->capture_handle && driver->playback_handle) {
 666                 if (cr != pr) {
 667                         jack_error ("playback and capture sample rates do "
 668                                     "not match (%d vs. %d)", pr, cr);
 669                 }
 670
 671                 /* only change if *both* capture and playback rates
 672                  * don't match requested certain hardware actually
 673                  * still works properly in full-duplex with slightly
 674                  * different rate values between adc and dac
 675                  */
 676                 if (cr != driver->frame_rate && pr != driver->frame_rate) {
 677                         jack_error ("sample rate in use (%d Hz) does not "
 678                                     "match requested rate (%d Hz)",
 679                                     cr, driver->frame_rate);
 680                         driver->frame_rate = cr;
 681                 }
 682
 683         }
 684         else if (driver->capture_handle && cr != driver->frame_rate) {
 685                 jack_error ("capture sample rate in use (%d Hz) does not "
 686                             "match requested rate (%d Hz)",
 687                             cr, driver->frame_rate);
 688                 driver->frame_rate = cr;
 689         }
 690         else if (driver->playback_handle && pr != driver->frame_rate) {
 691                 jack_error ("playback sample rate in use (%d Hz) does not "
 692                             "match requested rate (%d Hz)",
 693                             pr, driver->frame_rate);
 694                 driver->frame_rate = pr;
 695         }
 696
 697
 698         /* check the fragment size, since thats non-negotiable */
 699
 700         if (driver->playback_handle) {
 701                 snd_pcm_access_t access;
 702
 703                 err = snd_pcm_hw_params_get_period_size (
 704                         driver->playback_hw_params, &p_period_size, &dir);
 705                 err = snd_pcm_hw_params_get_format (
 706                         driver->playback_hw_params,
 707                         &(driver->playback_sample_format));
 708                 err = snd_pcm_hw_params_get_access (driver->playback_hw_params,
 709                                                     &access);
 710                 driver->playback_interleaved =
 711                         (access == SND_PCM_ACCESS_MMAP_INTERLEAVED)
 712                         || (access == SND_PCM_ACCESS_MMAP_COMPLEX);
 713
 714                 if (p_period_size != driver->frames_per_cycle) {
 715                         jack_error ("alsa_pcm: requested an interrupt every %"
 716                                     PRIu32
 717                                     " frames but got %u frames for playback",
 718                                     driver->frames_per_cycle, p_period_size);
 719                         return -1;
 720                 }
 721         }
 722
 723         if (driver->capture_handle) {
 724                 snd_pcm_access_t access;
 725
 726                 err = snd_pcm_hw_params_get_period_size (
 727                         driver->capture_hw_params, &c_period_size, &dir);
 728                 err = snd_pcm_hw_params_get_format (
 729                         driver->capture_hw_params,
 730                         &(driver->capture_sample_format));
 731                 err = snd_pcm_hw_params_get_access (driver->capture_hw_params,
 732                                                     &access);
 733                 driver->capture_interleaved =
 734                         (access == SND_PCM_ACCESS_MMAP_INTERLEAVED)
 735                         || (access == SND_PCM_ACCESS_MMAP_COMPLEX);
 736
 737                 if (c_period_size != driver->frames_per_cycle) {
 738                         jack_error ("alsa_pcm: requested an interrupt every %"
 739                                     PRIu32
 740                                     " frames but got %uc frames for capture",
 741                                     driver->frames_per_cycle, p_period_size);
 742                         return -1;
 743                 }
 744         }
 745
 746         driver->playback_sample_bytes =
 747                 snd_pcm_format_physical_width (driver->playback_sample_format)
 748                 / 8;
 749         driver->capture_sample_bytes =
 750                 snd_pcm_format_physical_width (driver->capture_sample_format)
 751                 / 8;
 752
 753         if (driver->playback_handle) {
 754                 switch (driver->playback_sample_format) {
 755         case SND_PCM_FORMAT_FLOAT_LE:
 756                 case SND_PCM_FORMAT_S32_LE:
 757                 case SND_PCM_FORMAT_S24_3LE:
 758                 case SND_PCM_FORMAT_S24_3BE:
 759                 case SND_PCM_FORMAT_S16_LE:
 760                 case SND_PCM_FORMAT_S32_BE:
 761                 case SND_PCM_FORMAT_S16_BE:
 762                         break;
 763
 764                 default:
 765                         jack_error ("programming error: unhandled format "
 766                                     "type for playback");
 767                         exit (1);
 768                 }
 769         }
 770
 771         if (driver->capture_handle) {
 772                 switch (driver->capture_sample_format) {
 773         case SND_PCM_FORMAT_FLOAT_LE:
 774                 case SND_PCM_FORMAT_S32_LE:
 775                 case SND_PCM_FORMAT_S24_3LE:
 776                 case SND_PCM_FORMAT_S24_3BE:
 777                 case SND_PCM_FORMAT_S16_LE:
 778                 case SND_PCM_FORMAT_S32_BE:
 779                 case SND_PCM_FORMAT_S16_BE:
 780                         break;
 781
 782                 default:
 783                         jack_error ("programming error: unhandled format "
 784                                     "type for capture");
 785                         exit (1);
 786                 }
 787         }
 788
 789         if (driver->playback_interleaved) {
 790                 const snd_pcm_channel_area_t *my_areas;
 791                 snd_pcm_uframes_t offset, frames;
 792                 if (snd_pcm_mmap_begin(driver->playback_handle,
 793                                        &my_areas, &offset, &frames) < 0) {
 794                         jack_error ("ALSA: %s: mmap areas info error",
 795                                     driver->alsa_name_playback);
 796                         return -1;
 797                 }
 798                 driver->interleave_unit =
 799                         snd_pcm_format_physical_width (
 800                                 driver->playback_sample_format) / 8;
 801         } else {
 802                 driver->interleave_unit = 0;  /* NOT USED */
 803         }
 804
 805         if (driver->capture_interleaved) {
 806                 const snd_pcm_channel_area_t *my_areas;
 807                 snd_pcm_uframes_t offset, frames;
 808                 if (snd_pcm_mmap_begin(driver->capture_handle,
 809                                        &my_areas, &offset, &frames) < 0) {
 810                         jack_error ("ALSA: %s: mmap areas info error",
 811                                     driver->alsa_name_capture);
 812                         return -1;
 813                 }
 814         }
 815
 816         if (driver->playback_nchannels > driver->capture_nchannels) {
 817                 driver->max_nchannels = driver->playback_nchannels;
 818                 driver->user_nchannels = driver->capture_nchannels;
 819         } else {
 820                 driver->max_nchannels = driver->capture_nchannels;
 821                 driver->user_nchannels = driver->playback_nchannels;
 822         }
 823
 824         alsa_driver_setup_io_function_pointers (driver);
 825
 826         /* Allocate and initialize structures that rely on the
 827            channels counts.
 828
 829            Set up the bit pattern that is used to record which
 830            channels require action on every cycle. any bits that are
 831            not set after the engine's process() call indicate channels
 832            that potentially need to be silenced.
 833         */
 834
 835         bitset_create (&driver->channels_done, driver->max_nchannels);
 836         bitset_create (&driver->channels_not_done, driver->max_nchannels);
 837
 838         if (driver->playback_handle) {
 839                 driver->playback_addr = (char **)
 840                         malloc (sizeof (char *) * driver->playback_nchannels);
 841                 memset (driver->playback_addr, 0,
 842                         sizeof (char *) * driver->playback_nchannels);
 843                 driver->playback_interleave_skip = (unsigned long *)
 844                         malloc (sizeof (unsigned long *) * driver->playback_nchannels);
 845                 memset (driver->playback_interleave_skip, 0,
 846                         sizeof (unsigned long *) * driver->playback_nchannels);
 847                 driver->silent = (unsigned long *)
 848                         malloc (sizeof (unsigned long)
 849                                 * driver->playback_nchannels);
 850
 851                 for (chn = 0; chn < driver->playback_nchannels; chn++) {
 852                         driver->silent[chn] = 0;
 853                 }
 854
 855                 for (chn = 0; chn < driver->playback_nchannels; chn++) {
 856                         bitset_add (driver->channels_done, chn);
 857                 }
 858
 859                 driver->dither_state = (dither_state_t *)
 860                         calloc ( driver->playback_nchannels,
 861                                  sizeof (dither_state_t));
 862         }
 863
 864         if (driver->capture_handle) {
 865                 driver->capture_addr = (char **)
 866                         malloc (sizeof (char *) * driver->capture_nchannels);
 867                 memset (driver->capture_addr, 0,
 868                         sizeof (char *) * driver->capture_nchannels);
 869                 driver->capture_interleave_skip = (unsigned long *)
 870                         malloc (sizeof (unsigned long *) * driver->capture_nchannels);
 871                 memset (driver->capture_interleave_skip, 0,
 872                         sizeof (unsigned long *) * driver->capture_nchannels);
 873         }
 874
 875         driver->clock_sync_data = (ClockSyncStatus *)
 876                 malloc (sizeof (ClockSyncStatus) * driver->max_nchannels);
 877
 878         driver->period_usecs =
 879                 (jack_time_t) floor ((((float) driver->frames_per_cycle) /
 880                                       driver->frame_rate) * 1000000.0f);
 881         driver->poll_timeout = (int) floor (1.5f * driver->period_usecs);
 882
 883 // JACK2
 884 /*
 885         if (driver->engine) {
 886                 if (driver->engine->set_buffer_size (driver->engine,
 887                                                      driver->frames_per_cycle)) {
 888                         jack_error ("ALSA: Cannot set engine buffer size to %d (check MIDI)", driver->frames_per_cycle);
 889                         return -1;
 890                 }
 891         }
 892 */
 893
 894         return 0;
 895 }
 896
 897 int
 898 alsa_driver_reset_parameters (alsa_driver_t *driver,
 899                               jack_nframes_t frames_per_cycle,
 900                               jack_nframes_t user_nperiods,
 901                               jack_nframes_t rate)
 902 {
 903         /* XXX unregister old ports ? */
 904         alsa_driver_release_channel_dependent_memory (driver);
 905         return alsa_driver_set_parameters (driver,
 906                                            frames_per_cycle,
 907                                            user_nperiods, rate);
 908 }
 909
 910 static int
 911 alsa_driver_get_channel_addresses (alsa_driver_t *driver,
 912                                    snd_pcm_uframes_t *capture_avail,
 913                                    snd_pcm_uframes_t *playback_avail,
 914                                    snd_pcm_uframes_t *capture_offset,
 915                                    snd_pcm_uframes_t *playback_offset)
 916 {
 917         unsigned long err;
 918         channel_t chn;
 919
 920         if (capture_avail) {
 921                 if ((err = snd_pcm_mmap_begin (
 922                              driver->capture_handle, &driver->capture_areas,
 923                              (snd_pcm_uframes_t *) capture_offset,
 924                              (snd_pcm_uframes_t *) capture_avail)) < 0) {
 925                         jack_error ("ALSA: %s: mmap areas info error",
 926                                     driver->alsa_name_capture);
 927                         return -1;
 928                 }
 929
 930                 for (chn = 0; chn < driver->capture_nchannels; chn++) {
 931                         const snd_pcm_channel_area_t *a =
 932                                 &driver->capture_areas[chn];
 933                         driver->capture_addr[chn] = (char *) a->addr
 934                                 + ((a->first + a->step * *capture_offset) / 8);
 935                         driver->capture_interleave_skip[chn] = (unsigned long ) (a->step / 8);
 936                 }
 937         }
 938
 939         if (playback_avail) {
 940                 if ((err = snd_pcm_mmap_begin (
 941                              driver->playback_handle, &driver->playback_areas,
 942                              (snd_pcm_uframes_t *) playback_offset,
 943                              (snd_pcm_uframes_t *) playback_avail)) < 0) {
 944                         jack_error ("ALSA: %s: mmap areas info error ",
 945                                     driver->alsa_name_playback);
 946                         return -1;
 947                 }
 948
 949                 for (chn = 0; chn < driver->playback_nchannels; chn++) {
 950                         const snd_pcm_channel_area_t *a =
 951                                 &driver->playback_areas[chn];
 952                         driver->playback_addr[chn] = (char *) a->addr
 953                                 + ((a->first + a->step * *playback_offset) / 8);
 954                         driver->playback_interleave_skip[chn] = (unsigned long ) (a->step / 8);
 955                 }
 956         }
 957
 958         return 0;
 959 }
 960
 961 int
 962 alsa_driver_start (alsa_driver_t *driver)
 963 {
 964         int err;
 965         snd_pcm_uframes_t poffset, pavail;
 966         channel_t chn;
 967
 968         driver->poll_last = 0;
 969         driver->poll_next = 0;
 970
 971         if (driver->playback_handle) {
 972                 if ((err = snd_pcm_prepare (driver->playback_handle)) < 0) {
 973                         jack_error ("ALSA: prepare error for playback on "
 974                                     "\"%s\" (%s)", driver->alsa_name_playback,
 975                                     snd_strerror(err));
 976                         return -1;
 977                 }
 978         }
 979
 980         if ((driver->capture_handle && driver->capture_and_playback_not_synced)
 981             || !driver->playback_handle) {
 982                 if ((err = snd_pcm_prepare (driver->capture_handle)) < 0) {
 983                         jack_error ("ALSA: prepare error for capture on \"%s\""
 984                                     " (%s)", driver->alsa_name_capture,
 985                                     snd_strerror(err));
 986                         return -1;
 987                 }
 988         }
 989
 990         if (driver->hw_monitoring) {
 991                 if (driver->input_monitor_mask || driver->all_monitor_in) {
 992                         if (driver->all_monitor_in) {
 993                                 driver->hw->set_input_monitor_mask (driver->hw, ~0U);
 994                         } else {
 995                                 driver->hw->set_input_monitor_mask (
 996                                         driver->hw, driver->input_monitor_mask);
 997                         }
 998                 } else {
 999                         driver->hw->set_input_monitor_mask (driver->hw,
1000                                                             driver->input_monitor_mask);
1001                 }
1002         }
1003
1004         if (driver->playback_handle) {
1005                 driver->playback_nfds =
1006                         snd_pcm_poll_descriptors_count (driver->playback_handle);
1007         } else {
1008                 driver->playback_nfds = 0;
1009         }
1010
1011         if (driver->capture_handle) {
1012                 driver->capture_nfds =
1013                         snd_pcm_poll_descriptors_count (driver->capture_handle);
1014         } else {
1015                 driver->capture_nfds = 0;
1016         }
1017
1018         if (driver->pfd) {
1019                 free (driver->pfd);
1020         }
1021
1022         driver->pfd = (struct pollfd *)
1023                 malloc (sizeof (struct pollfd) *
1024                         (driver->playback_nfds + driver->capture_nfds + 2));
1025
1026         if (driver->midi && !driver->xrun_recovery)
1027                 (driver->midi->start)(driver->midi);
1028
1029         if (driver->playback_handle) {
1030                 /* fill playback buffer with zeroes, and mark
1031                    all fragments as having data.
1032                 */
1033
1034                 pavail = snd_pcm_avail_update (driver->playback_handle);
1035
1036                 if (pavail !=
1037                     driver->frames_per_cycle * driver->playback_nperiods) {
1038                         jack_error ("ALSA: full buffer not available at start");
1039                         return -1;
1040                 }
1041
1042                 if (alsa_driver_get_channel_addresses (driver,
1043                                         0, &pavail, 0, &poffset)) {
1044                         return -1;
1045                 }
1046
1047                 /* XXX this is cheating. ALSA offers no guarantee that
1048                    we can access the entire buffer at any one time. It
1049                    works on most hardware tested so far, however, buts
1050                    its a liability in the long run. I think that
1051                    alsa-lib may have a better function for doing this
1052                    here, where the goal is to silence the entire
1053                    buffer.
1054                 */
1055
1056                 for (chn = 0; chn < driver->playback_nchannels; chn++) {
1057                         alsa_driver_silence_on_channel (
1058                                 driver, chn,
1059                                 driver->user_nperiods
1060                                 * driver->frames_per_cycle);
1061                 }
1062
1063                 snd_pcm_mmap_commit (driver->playback_handle, poffset,
1064                                      driver->user_nperiods
1065                                      * driver->frames_per_cycle);
1066
1067                 if ((err = snd_pcm_start (driver->playback_handle)) < 0) {
1068                         jack_error ("ALSA: could not start playback (%s)",
1069                                     snd_strerror (err));
1070                         return -1;
1071                 }
1072         }
1073
1074         if ((driver->capture_handle && driver->capture_and_playback_not_synced)
1075             || !driver->playback_handle) {
1076                 if ((err = snd_pcm_start (driver->capture_handle)) < 0) {
1077                         jack_error ("ALSA: could not start capture (%s)",
1078                                     snd_strerror (err));
1079                         return -1;
1080                 }
1081         }
1082
1083         return 0;
1084 }
1085
1086 int
1087 alsa_driver_stop (alsa_driver_t *driver)
1088 {
1089         int err;
1090 //      JSList* node;
1091 //      int chn;
1092
1093         /* silence all capture port buffers, because we might
1094            be entering offline mode.
1095         */
1096
1097 // JACK2
1098 /*
1099         for (chn = 0, node = driver->capture_ports; node;
1100              node = jack_slist_next (node), chn++) {
1101
1102                 jack_port_t* port;
1103                 char* buf;
1104                 jack_nframes_t nframes = driver->engine->control->buffer_size;
1105
1106                 port = (jack_port_t *) node->data;
1107                 buf = jack_port_get_buffer (port, nframes);
1108                 memset (buf, 0, sizeof (jack_default_audio_sample_t) * nframes);
1109         }
1110 */
1111
1112 // JACK2
1113     ClearOutput();
1114
1115         if (driver->playback_handle) {
1116                 if ((err = snd_pcm_drop (driver->playback_handle)) < 0) {
1117                         jack_error ("ALSA: channel flush for playback "
1118                                     "failed (%s)", snd_strerror (err));
1119                         return -1;
1120                 }
1121         }
1122
1123         if (!driver->playback_handle
1124             || driver->capture_and_playback_not_synced) {
1125                 if (driver->capture_handle) {
1126                         if ((err = snd_pcm_drop (driver->capture_handle)) < 0) {
1127                                 jack_error ("ALSA: channel flush for "
1128                                             "capture failed (%s)",
1129                                             snd_strerror (err));
1130                                 return -1;
1131                         }
1132                 }
1133         }
1134
1135         if (driver->hw_monitoring) {
1136                 driver->hw->set_input_monitor_mask (driver->hw, 0);
1137         }
1138
1139         if (driver->midi && !driver->xrun_recovery)
1140                 (driver->midi->stop)(driver->midi);
1141
1142         return 0;
1143 }
1144
1145 static int
1146 alsa_driver_restart (alsa_driver_t *driver)
1147 {
1148         int res;
1149
1150         driver->xrun_recovery = 1;
1151     // JACK2
1152     /*
1153         if ((res = driver->nt_stop((struct _jack_driver_nt *) driver))==0)
1154                 res = driver->nt_start((struct _jack_driver_nt *) driver);
1155     */
1156     res = Restart();
1157         driver->xrun_recovery = 0;
1158
1159         if (res && driver->midi)
1160                 (driver->midi->stop)(driver->midi);
1161
1162         return res;
1163 }
1164
1165 static int
1166 alsa_driver_xrun_recovery (alsa_driver_t *driver, float *delayed_usecs)
1167 {
1168         snd_pcm_status_t *status;
1169         int res;
1170
1171         snd_pcm_status_alloca(&status);
1172
1173         if (driver->capture_handle) {
1174                 if ((res = snd_pcm_status(driver->capture_handle, status))
1175                     < 0) {
1176                         jack_error("status error: %s", snd_strerror(res));
1177                 }
1178         } else {
1179                 if ((res = snd_pcm_status(driver->playback_handle, status))
1180                     < 0) {
1181                         jack_error("status error: %s", snd_strerror(res));
1182                 }
1183         }
1184
1185         if (snd_pcm_status_get_state(status) == SND_PCM_STATE_SUSPENDED)
1186         {
1187                 jack_log("**** alsa_pcm: pcm in suspended state, resuming it" );
1188                 if (driver->capture_handle) {
1189                         if ((res = snd_pcm_prepare(driver->capture_handle))
1190                             < 0) {
1191                                 jack_error("error preparing after suspend: %s", snd_strerror(res));
1192                         }
1193                 } else {
1194                         if ((res = snd_pcm_prepare(driver->playback_handle))
1195                             < 0) {
1196                                 jack_error("error preparing after suspend: %s", snd_strerror(res));
1197                         }
1198                 }
1199         }
1200
1201         if (snd_pcm_status_get_state(status) == SND_PCM_STATE_XRUN
1202             && driver->process_count > XRUN_REPORT_DELAY) {
1203                 struct timeval now, diff, tstamp;
1204                 driver->xrun_count++;
1205                 snd_pcm_status_get_tstamp(status,&now);
1206                 snd_pcm_status_get_trigger_tstamp(status, &tstamp);
1207                 timersub(&now, &tstamp, &diff);
1208                 *delayed_usecs = diff.tv_sec * 1000000.0 + diff.tv_usec;
1209                 jack_log("**** alsa_pcm: xrun of at least %.3f msecs",*delayed_usecs / 1000.0);
1210         }
1211
1212         if (alsa_driver_restart (driver)) {
1213                 return -1;
1214         }
1215         return 0;
1216 }
1217
1218 void
1219 alsa_driver_silence_untouched_channels (alsa_driver_t *driver,
1220                                         jack_nframes_t nframes)
1221 {
1222         channel_t chn;
1223         jack_nframes_t buffer_frames =
1224                 driver->frames_per_cycle * driver->playback_nperiods;
1225
1226         for (chn = 0; chn < driver->playback_nchannels; chn++) {
1227                 if (bitset_contains (driver->channels_not_done, chn)) {
1228                         if (driver->silent[chn] < buffer_frames) {
1229                                 alsa_driver_silence_on_channel_no_mark (
1230                                         driver, chn, nframes);
1231                                 driver->silent[chn] += nframes;
1232                         }
1233                 }
1234         }
1235 }
1236
1237 void
1238 alsa_driver_set_clock_sync_status (alsa_driver_t *driver, channel_t chn,
1239                                    ClockSyncStatus status)
1240 {
1241         driver->clock_sync_data[chn] = status;
1242         alsa_driver_clock_sync_notify (driver, chn, status);
1243 }
1244
1245 static int under_gdb = FALSE;
1246
1247 jack_nframes_t
1248 alsa_driver_wait (alsa_driver_t *driver, int extra_fd, int *status, float
1249                   *delayed_usecs)
1250 {
1251         snd_pcm_sframes_t avail = 0;
1252         snd_pcm_sframes_t capture_avail = 0;
1253         snd_pcm_sframes_t playback_avail = 0;
1254         int xrun_detected = FALSE;
1255         int need_capture;
1256         int need_playback;
1257         unsigned int i;
1258         jack_time_t poll_enter;
1259         jack_time_t poll_ret = 0;
1260
1261         *status = -1;
1262         *delayed_usecs = 0;
1263
1264         need_capture = driver->capture_handle ? 1 : 0;
1265
1266         if (extra_fd >= 0) {
1267                 need_playback = 0;
1268         } else {
1269                 need_playback = driver->playback_handle ? 1 : 0;
1270         }
1271
1272   again:
1273
1274         while (need_playback || need_capture) {
1275
1276                 int poll_result;
1277                 unsigned int ci = 0;
1278                 unsigned int nfds;
1279                 unsigned short revents;
1280
1281                 nfds = 0;
1282
1283                 if (need_playback) {
1284                         snd_pcm_poll_descriptors (driver->playback_handle,
1285                                                   &driver->pfd[0],
1286                                                   driver->playback_nfds);
1287                         nfds += driver->playback_nfds;
1288                 }
1289
1290                 if (need_capture) {
1291                         snd_pcm_poll_descriptors (driver->capture_handle,
1292                                                   &driver->pfd[nfds],
1293                                                   driver->capture_nfds);
1294                         ci = nfds;
1295                         nfds += driver->capture_nfds;
1296                 }
1297
1298                 /* ALSA doesn't set POLLERR in some versions of 0.9.X */
1299
1300                 for (i = 0; i < nfds; i++) {
1301                         driver->pfd[i].events |= POLLERR;
1302                 }
1303
1304                 if (extra_fd >= 0) {
1305                         driver->pfd[nfds].fd = extra_fd;
1306                         driver->pfd[nfds].events =
1307                                 POLLIN|POLLERR|POLLHUP|POLLNVAL;
1308                         nfds++;
1309                 }
1310
1311                 poll_enter = jack_get_microseconds ();
1312
1313                 if (poll_enter > driver->poll_next) {
1314                         /*
1315                          * This processing cycle was delayed past the
1316                          * next due interrupt!  Do not account this as
1317                          * a wakeup delay:
1318                          */
1319                         driver->poll_next = 0;
1320                         driver->poll_late++;
1321                 }
1322
1323                 poll_result = poll (driver->pfd, nfds, driver->poll_timeout);
1324                 if (poll_result < 0) {
1325
1326                         if (errno == EINTR) {
1327                                 jack_info ("poll interrupt");
1328                                 // this happens mostly when run
1329                                 // under gdb, or when exiting due to a signal
1330                                 if (under_gdb) {
1331                                         goto again;
1332                                 }
1333                                 *status = -2;
1334                                 return 0;
1335                         }
1336
1337                         jack_error ("ALSA: poll call failed (%s)",
1338                                     strerror (errno));
1339                         *status = -3;
1340                         return 0;
1341
1342                 }
1343
1344                 poll_ret = jack_get_microseconds ();
1345
1346         // JACK2
1347         SetTime(poll_ret);
1348
1349                 if (extra_fd < 0) {
1350                         if (driver->poll_next && poll_ret > driver->poll_next) {
1351                                 *delayed_usecs = poll_ret - driver->poll_next;
1352                         }
1353                         driver->poll_last = poll_ret;
1354                         driver->poll_next = poll_ret + driver->period_usecs;
1355 // JACK2
1356 /*
1357                         driver->engine->transport_cycle_start (driver->engine,
1358                                                                poll_ret);
1359 */
1360                 }
1361
1362 #ifdef DEBUG_WAKEUP
1363                 fprintf (stderr, "%" PRIu64 ": checked %d fds, started at %" PRIu64 " %" PRIu64 "  usecs since poll entered\n",
1364                          poll_ret, nfds, poll_enter, poll_ret - poll_enter);
1365 #endif
1366
1367                 /* check to see if it was the extra FD that caused us
1368                  * to return from poll */
1369
1370                 if (extra_fd >= 0) {
1371
1372                         if (driver->pfd[nfds-1].revents == 0) {
1373                                 /* we timed out on the extra fd */
1374
1375                                 *status = -4;
1376                                 return -1;
1377                         }
1378
1379                         /* if POLLIN was the only bit set, we're OK */
1380
1381                         *status = 0;
1382                         return (driver->pfd[nfds-1].revents == POLLIN) ? 0 : -1;
1383                 }
1384
1385                 if (need_playback) {
1386                         if (snd_pcm_poll_descriptors_revents
1387                             (driver->playback_handle, &driver->pfd[0],
1388                              driver->playback_nfds, &revents) < 0) {
1389                                 jack_error ("ALSA: playback revents failed");
1390                                 *status = -6;
1391                                 return 0;
1392                         }
1393
1394                         if (revents & POLLERR) {
1395                                 xrun_detected = TRUE;
1396                         }
1397
1398                         if (revents & POLLOUT) {
1399                                 need_playback = 0;
1400 #ifdef DEBUG_WAKEUP
1401                                 fprintf (stderr, "%" PRIu64
1402                                          " playback stream ready\n",
1403                                          poll_ret);
1404 #endif
1405                         }
1406                 }
1407
1408                 if (need_capture) {
1409                         if (snd_pcm_poll_descriptors_revents
1410                             (driver->capture_handle, &driver->pfd[ci],
1411                              driver->capture_nfds, &revents) < 0) {
1412                                 jack_error ("ALSA: capture revents failed");
1413                                 *status = -6;
1414                                 return 0;
1415                         }
1416
1417                         if (revents & POLLERR) {
1418                                 xrun_detected = TRUE;
1419                         }
1420
1421                         if (revents & POLLIN) {
1422                                 need_capture = 0;
1423 #ifdef DEBUG_WAKEUP
1424                                 fprintf (stderr, "%" PRIu64
1425                                          " capture stream ready\n",
1426                                          poll_ret);
1427 #endif
1428                         }
1429                 }
1430
1431                 if (poll_result == 0) {
1432                         jack_error ("ALSA: poll time out, polled for %" PRIu64
1433                                     " usecs",
1434                                     poll_ret - poll_enter);
1435                         *status = -5;
1436                         return 0;
1437                 }
1438
1439         }
1440
1441         if (driver->capture_handle) {
1442                 if ((capture_avail = snd_pcm_avail_update (
1443                              driver->capture_handle)) < 0) {
1444                         if (capture_avail == -EPIPE) {
1445                                 xrun_detected = TRUE;
1446                         } else {
1447                                 jack_error ("unknown ALSA avail_update return"
1448                                             " value (%u)", capture_avail);
1449                         }
1450                 }
1451         } else {
1452                 /* odd, but see min() computation below */
1453                 capture_avail = INT_MAX;
1454         }
1455
1456         if (driver->playback_handle) {
1457                 if ((playback_avail = snd_pcm_avail_update (
1458                              driver->playback_handle)) < 0) {
1459                         if (playback_avail == -EPIPE) {
1460                                 xrun_detected = TRUE;
1461                         } else {
1462                                 jack_error ("unknown ALSA avail_update return"
1463                                             " value (%u)", playback_avail);
1464                         }
1465                 }
1466         } else {
1467                 /* odd, but see min() computation below */
1468                 playback_avail = INT_MAX;
1469         }
1470
1471         if (xrun_detected) {
1472                 *status = alsa_driver_xrun_recovery (driver, delayed_usecs);
1473                 return 0;
1474         }
1475
1476         *status = 0;
1477         driver->last_wait_ust = poll_ret;
1478
1479         avail = capture_avail < playback_avail ? capture_avail : playback_avail;
1480
1481 #ifdef DEBUG_WAKEUP
1482         fprintf (stderr, "wakeup complete, avail = %lu, pavail = %lu "
1483                  "cavail = %lu\n",
1484                  avail, playback_avail, capture_avail);
1485 #endif
1486
1487         /* mark all channels not done for now. read/write will change this */
1488
1489         bitset_copy (driver->channels_not_done, driver->channels_done);
1490
1491         /* constrain the available count to the nearest (round down) number of
1492            periods.
1493         */
1494
1495         return avail - (avail % driver->frames_per_cycle);
1496 }
1497
1498
1499 int
1500 alsa_driver_read (alsa_driver_t *driver, jack_nframes_t nframes)
1501 {
1502         snd_pcm_sframes_t contiguous;
1503         snd_pcm_sframes_t nread;
1504         snd_pcm_uframes_t offset;
1505         jack_nframes_t  orig_nframes;
1506 //      jack_default_audio_sample_t* buf;
1507 //      channel_t chn;
1508 //      JSList *node;
1509 //      jack_port_t* port;
1510         int err;
1511
1512         if (nframes > driver->frames_per_cycle) {
1513                 return -1;
1514         }
1515
1516 // JACK2
1517 /*
1518         if (driver->engine->freewheeling) {
1519                 return 0;
1520         }
1521 */
1522         if (driver->midi)
1523                 (driver->midi->read)(driver->midi, nframes);
1524
1525         if (!driver->capture_handle) {
1526                 return 0;
1527         }
1528
1529         nread = 0;
1530         contiguous = 0;
1531         orig_nframes = nframes;
1532
1533         while (nframes) {
1534
1535                 contiguous = nframes;
1536
1537                 if (alsa_driver_get_channel_addresses (
1538                             driver,
1539                             (snd_pcm_uframes_t *) &contiguous,
1540                             (snd_pcm_uframes_t *) 0,
1541                             &offset, 0) < 0) {
1542                         return -1;
1543                 }
1544 // JACK2
1545 /*
1546                 for (chn = 0, node = driver->capture_ports; node;
1547                      node = jack_slist_next (node), chn++) {
1548
1549                         port = (jack_port_t *) node->data;
1550
1551                         if (!jack_port_connected (port)) {
1552                                 // no-copy optimization
1553                                 continue;
1554                         }
1555                         buf = jack_port_get_buffer (port, orig_nframes);
1556                         alsa_driver_read_from_channel (driver, chn,
1557                                 buf + nread, contiguous);
1558                 }
1559 */
1560         ReadInput(orig_nframes, contiguous, nread);
1561
1562                 if ((err = snd_pcm_mmap_commit (driver->capture_handle,
1563                                 offset, contiguous)) < 0) {
1564                         jack_error ("ALSA: could not complete read of %"
1565                                 PRIu32 " frames: error = %d", contiguous, err);
1566                         return -1;
1567                 }
1568
1569                 nframes -= contiguous;
1570                 nread += contiguous;
1571         }
1572
1573         return 0;
1574 }
1575
1576 int
1577 alsa_driver_write (alsa_driver_t* driver, jack_nframes_t nframes)
1578 {
1579 //      channel_t chn;
1580 //      JSList *node;
1581 //      JSList *mon_node;
1582 //      jack_default_audio_sample_t* buf;
1583 //      jack_default_audio_sample_t* monbuf;
1584         jack_nframes_t orig_nframes;
1585         snd_pcm_sframes_t nwritten;
1586         snd_pcm_sframes_t contiguous;
1587         snd_pcm_uframes_t offset;
1588 //      jack_port_t *port;
1589         int err;
1590
1591         driver->process_count++;
1592
1593 // JACK2
1594 /*
1595         if (!driver->playback_handle || driver->engine->freewheeling) {
1596                 return 0;
1597         }
1598 */
1599         if (!driver->playback_handle) {
1600                 return 0;
1601         }
1602
1603         if (nframes > driver->frames_per_cycle) {
1604                 return -1;
1605         }
1606
1607         if (driver->midi)
1608                 (driver->midi->write)(driver->midi, nframes);
1609
1610         nwritten = 0;
1611         contiguous = 0;
1612         orig_nframes = nframes;
1613
1614         /* check current input monitor request status */
1615
1616         driver->input_monitor_mask = 0;
1617
1618 // JACK2
1619 /*
1620         for (chn = 0, node = driver->capture_ports; node;
1621              node = jack_slist_next (node), chn++) {
1622                 if (((jack_port_t *) node->data)->shared->monitor_requests) {
1623                         driver->input_monitor_mask |= (1<<chn);
1624                 }
1625         }
1626 */
1627     MonitorInput();
1628
1629         if (driver->hw_monitoring) {
1630                 if ((driver->hw->input_monitor_mask
1631                      != driver->input_monitor_mask)
1632                     && !driver->all_monitor_in) {
1633                         driver->hw->set_input_monitor_mask (
1634                                 driver->hw, driver->input_monitor_mask);
1635                 }
1636         }
1637
1638         while (nframes) {
1639
1640                 contiguous = nframes;
1641
1642                 if (alsa_driver_get_channel_addresses (
1643                             driver,
1644                             (snd_pcm_uframes_t *) 0,
1645                             (snd_pcm_uframes_t *) &contiguous,
1646                             0, &offset) < 0) {
1647                         return -1;
1648                 }
1649
1650 // JACK2
1651 /*
1652                 for (chn = 0, node = driver->playback_ports, mon_node=driver->monitor_ports;
1653                      node;
1654                      node = jack_slist_next (node), chn++) {
1655
1656                         port = (jack_port_t *) node->data;
1657
1658                         if (!jack_port_connected (port)) {
1659                                 continue;
1660                         }
1661                         buf = jack_port_get_buffer (port, orig_nframes);
1662                         alsa_driver_write_to_channel (driver, chn,
1663                                 buf + nwritten, contiguous);
1664
1665                         if (mon_node) {
1666                                 port = (jack_port_t *) mon_node->data;
1667                                 if (!jack_port_connected (port)) {
1668                                         continue;
1669                                 }
1670                                 monbuf = jack_port_get_buffer (port, orig_nframes);
1671                                 memcpy (monbuf + nwritten, buf + nwritten, contiguous * sizeof(jack_default_audio_sample_t));
1672                                 mon_node = jack_slist_next (mon_node);
1673                         }
1674                 }
1675 */
1676
1677         // JACK2
1678         WriteOutput(orig_nframes, contiguous, nwritten);
1679
1680                 if (!bitset_empty (driver->channels_not_done)) {
1681                         alsa_driver_silence_untouched_channels (driver,
1682                                                                 contiguous);
1683                 }
1684
1685                 if ((err = snd_pcm_mmap_commit (driver->playback_handle,
1686                                 offset, contiguous)) < 0) {
1687                         jack_error ("ALSA: could not complete playback of %"
1688                                 PRIu32 " frames: error = %d", contiguous, err);
1689                         if (err != -EPIPE && err != -ESTRPIPE)
1690                                 return -1;
1691                 }
1692
1693                 nframes -= contiguous;
1694                 nwritten += contiguous;
1695         }
1696
1697         return 0;
1698 }
1699
1700 #if 0
1701 static int  /* UNUSED */
1702 alsa_driver_change_sample_clock (alsa_driver_t *driver, SampleClockMode mode)
1703 {
1704         return driver->hw->change_sample_clock (driver->hw, mode);
1705 }
1706
1707 static void  /* UNUSED */
1708 alsa_driver_request_all_monitor_input (alsa_driver_t *driver, int yn)
1709
1710 {
1711         if (driver->hw_monitoring) {
1712                 if (yn) {
1713                         driver->hw->set_input_monitor_mask (driver->hw, ~0U);
1714                 } else {
1715                         driver->hw->set_input_monitor_mask (
1716                                 driver->hw, driver->input_monitor_mask);
1717                 }
1718         }
1719
1720         driver->all_monitor_in = yn;
1721 }
1722
1723 static void  /* UNUSED */
1724 alsa_driver_set_hw_monitoring (alsa_driver_t *driver, int yn)
1725 {
1726         if (yn) {
1727                 driver->hw_monitoring = TRUE;
1728
1729                 if (driver->all_monitor_in) {
1730                         driver->hw->set_input_monitor_mask (driver->hw, ~0U);
1731                 } else {
1732                         driver->hw->set_input_monitor_mask (
1733                                 driver->hw, driver->input_monitor_mask);
1734                 }
1735         } else {
1736                 driver->hw_monitoring = FALSE;
1737                 driver->hw->set_input_monitor_mask (driver->hw, 0);
1738         }
1739 }
1740
1741 static ClockSyncStatus  /* UNUSED */
1742 alsa_driver_clock_sync_status (channel_t chn)
1743 {
1744         return Lock;
1745 }
1746 #endif
1747
1748 void
1749 alsa_driver_delete (alsa_driver_t *driver)
1750 {
1751         JSList *node;
1752
1753         if (driver->midi)
1754                 (driver->midi->destroy)(driver->midi);
1755
1756         for (node = driver->clock_sync_listeners; node;
1757              node = jack_slist_next (node)) {
1758                 free (node->data);
1759         }
1760         jack_slist_free (driver->clock_sync_listeners);
1761
1762         if (driver->ctl_handle) {
1763                 snd_ctl_close (driver->ctl_handle);
1764                 driver->ctl_handle = 0;
1765         }
1766
1767         if (driver->capture_handle) {
1768                 snd_pcm_close (driver->capture_handle);
1769                 driver->capture_handle = 0;
1770         }
1771
1772         if (driver->playback_handle) {
1773                 snd_pcm_close (driver->playback_handle);
1774                 driver->capture_handle = 0;
1775         }
1776
1777         if (driver->capture_hw_params) {
1778                 snd_pcm_hw_params_free (driver->capture_hw_params);
1779                 driver->capture_hw_params = 0;
1780         }
1781
1782         if (driver->playback_hw_params) {
1783                 snd_pcm_hw_params_free (driver->playback_hw_params);
1784                 driver->playback_hw_params = 0;
1785         }
1786
1787         if (driver->capture_sw_params) {
1788                 snd_pcm_sw_params_free (driver->capture_sw_params);
1789                 driver->capture_sw_params = 0;
1790         }
1791
1792         if (driver->playback_sw_params) {
1793                 snd_pcm_sw_params_free (driver->playback_sw_params);
1794                 driver->playback_sw_params = 0;
1795         }
1796
1797         if (driver->pfd) {
1798                 free (driver->pfd);
1799         }
1800
1801         if (driver->hw) {
1802                 driver->hw->release (driver->hw);
1803                 driver->hw = 0;
1804         }
1805         free(driver->alsa_name_playback);
1806         free(driver->alsa_name_capture);
1807         free(driver->alsa_driver);
1808
1809         alsa_driver_release_channel_dependent_memory (driver);
1810     //JACK2
1811     //jack_driver_nt_finish ((jack_driver_nt_t *) driver);
1812         free (driver);
1813 }
1814
1815 static char*
1816 discover_alsa_using_apps ()
1817 {
1818         char found[2048];
1819         char command[5192];
1820         char* path = getenv ("PATH");
1821         char* dir;
1822         size_t flen = 0;
1823         int card;
1824         int device;
1825         size_t cmdlen = 0;
1826
1827         if (!path) {
1828                 return NULL;
1829         }
1830
1831         /* look for lsof and give up if its not in PATH */
1832
1833         path = strdup (path);
1834         dir = strtok (path, ":");
1835         while (dir) {
1836                 char maybe[PATH_MAX+1];
1837                 snprintf (maybe, sizeof(maybe), "%s/lsof", dir);
1838                 if (access (maybe, X_OK)) {
1839                         break;
1840                 }
1841                 dir = strtok (NULL, ":");
1842         }
1843         free (path);
1844
1845         if (!dir) {
1846                 return NULL;
1847         }
1848
1849         snprintf (command, sizeof (command), "lsof -Fc0 ");
1850         cmdlen = strlen (command);
1851
1852         for (card = 0; card < 8; ++card) {
1853                 for (device = 0; device < 8; ++device)  {
1854                         char buf[32];
1855
1856                         snprintf (buf, sizeof (buf), "/dev/snd/pcmC%dD%dp", card, device);
1857                         if (access (buf, F_OK) == 0) {
1858                                 snprintf (command+cmdlen, sizeof(command)-cmdlen, "%s ", buf);
1859                         }
1860                         cmdlen = strlen (command);
1861
1862                         snprintf (buf, sizeof (buf), "/dev/snd/pcmC%dD%dc", card, device);
1863                         if (access (buf, F_OK) == 0) {
1864                                 snprintf (command+cmdlen, sizeof(command)-cmdlen, "%s ", buf);
1865                         }
1866                         cmdlen = strlen (command);
1867                 }
1868         }
1869
1870         FILE* f = popen (command, "r");
1871
1872         if (!f) {
1873                 return NULL;
1874         }
1875
1876         while (!feof (f)) {
1877                 char buf[1024]; /* lsof doesn't output much */
1878
1879                 if (!fgets (buf, sizeof (buf), f)) {
1880                         break;
1881                 }
1882
1883                 if (*buf != 'p') {
1884                         return NULL;
1885                 }
1886
1887                 /* buf contains NULL as a separator between the process field and the command field */
1888                 char *pid = buf;
1889                 ++pid; /* skip leading 'p' */
1890                 char *cmd = pid;
1891
1892                 /* skip to NULL */
1893                 while (*cmd) {
1894                         ++cmd;
1895                 }
1896                 ++cmd; /* skip to 'c' */
1897                 ++cmd; /* skip to first character of command */
1898
1899                 snprintf (found+flen, sizeof (found)-flen, "%s (process ID %s)\n", cmd, pid);
1900                 flen = strlen (found);
1901
1902                 if (flen >= sizeof (found)) {
1903                         break;
1904                 }
1905         }
1906
1907         pclose (f);
1908
1909         if (flen) {
1910                 return strdup (found);
1911         } else {
1912                 return NULL;
1913         }
1914 }
1915
1916 jack_driver_t *
1917 alsa_driver_new (char *name, char *playback_alsa_device,
1918                  char *capture_alsa_device,
1919                  jack_client_t *client,
1920                  jack_nframes_t frames_per_cycle,
1921                  jack_nframes_t user_nperiods,
1922                  jack_nframes_t rate,
1923                  int hw_monitoring,
1924                  int hw_metering,
1925                  int capturing,
1926                  int playing,
1927                  DitherAlgorithm dither,
1928                  int soft_mode,
1929                  int monitor,
1930                  int user_capture_nchnls,
1931                  int user_playback_nchnls,
1932                  int shorts_first,
1933                  jack_nframes_t capture_latency,
1934                  jack_nframes_t playback_latency,
1935                  alsa_midi_t *midi_driver
1936                  )
1937 {
1938         int err;
1939     char* current_apps;
1940         alsa_driver_t *driver;
1941
1942         jack_info ("creating alsa driver ... %s|%s|%" PRIu32 "|%" PRIu32
1943                 "|%" PRIu32"|%" PRIu32"|%" PRIu32 "|%s|%s|%s|%s",
1944                 playing ? playback_alsa_device : "-",
1945                 capturing ? capture_alsa_device : "-",
1946                 frames_per_cycle, user_nperiods, rate,
1947                 user_capture_nchnls,user_playback_nchnls,
1948                 hw_monitoring ? "hwmon": "nomon",
1949                 hw_metering ? "hwmeter":"swmeter",
1950                 soft_mode ? "soft-mode":"-",
1951                 shorts_first ? "16bit":"32bit");
1952
1953         driver = (alsa_driver_t *) calloc (1, sizeof (alsa_driver_t));
1954
1955         jack_driver_nt_init ((jack_driver_nt_t *) driver);
1956
1957     // JACK2
1958     /*
1959         driver->nt_attach = (JackDriverNTAttachFunction) alsa_driver_attach;
1960     driver->nt_detach = (JackDriverNTDetachFunction) alsa_driver_detach;
1961         driver->read = (JackDriverReadFunction) alsa_driver_read;
1962         driver->write = (JackDriverReadFunction) alsa_driver_write;
1963         driver->null_cycle = (JackDriverNullCycleFunction) alsa_driver_null_cycle;
1964         driver->nt_bufsize = (JackDriverNTBufSizeFunction) alsa_driver_bufsize;
1965         driver->nt_start = (JackDriverNTStartFunction) alsa_driver_start;
1966         driver->nt_stop = (JackDriverNTStopFunction) alsa_driver_stop;
1967         driver->nt_run_cycle = (JackDriverNTRunCycleFunction) alsa_driver_run_cycle;
1968     */
1969
1970         driver->playback_handle = NULL;
1971         driver->capture_handle = NULL;
1972         driver->ctl_handle = 0;
1973         driver->hw = 0;
1974         driver->capture_and_playback_not_synced = FALSE;
1975         driver->max_nchannels = 0;
1976         driver->user_nchannels = 0;
1977         driver->playback_nchannels = user_playback_nchnls;
1978         driver->capture_nchannels = user_capture_nchnls;
1979         driver->playback_sample_bytes = (shorts_first ? 2:4);
1980         driver->capture_sample_bytes = (shorts_first ? 2:4);
1981         driver->capture_frame_latency = capture_latency;
1982         driver->playback_frame_latency = playback_latency;
1983
1984         driver->playback_addr = 0;
1985         driver->capture_addr = 0;
1986         driver->playback_interleave_skip = NULL;
1987         driver->capture_interleave_skip = NULL;
1988
1989
1990         driver->silent = 0;
1991         driver->all_monitor_in = FALSE;
1992         driver->with_monitor_ports = monitor;
1993
1994         driver->clock_mode = ClockMaster; /* XXX is it? */
1995         driver->input_monitor_mask = 0;   /* XXX is it? */
1996
1997         driver->capture_ports = 0;
1998         driver->playback_ports = 0;
1999         driver->monitor_ports = 0;
2000
2001         driver->pfd = 0;
2002         driver->playback_nfds = 0;
2003         driver->capture_nfds = 0;
2004
2005         driver->dither = dither;
2006         driver->soft_mode = soft_mode;
2007
2008         driver->quirk_bswap = 0;
2009
2010         pthread_mutex_init (&driver->clock_sync_lock, 0);
2011         driver->clock_sync_listeners = 0;
2012
2013         driver->poll_late = 0;
2014         driver->xrun_count = 0;
2015         driver->process_count = 0;
2016
2017         driver->alsa_name_playback = strdup (playback_alsa_device);
2018         driver->alsa_name_capture = strdup (capture_alsa_device);
2019
2020         driver->midi = midi_driver;
2021         driver->xrun_recovery = 0;
2022
2023         if (alsa_driver_check_card_type (driver)) {
2024                 alsa_driver_delete (driver);
2025                 return NULL;
2026         }
2027
2028         alsa_driver_hw_specific (driver, hw_monitoring, hw_metering);
2029
2030         if (playing) {
2031                 if (snd_pcm_open (&driver->playback_handle,
2032                                   playback_alsa_device,
2033                                   SND_PCM_STREAM_PLAYBACK,
2034                                   SND_PCM_NONBLOCK) < 0) {
2035                         switch (errno) {
2036                         case EBUSY:
2037                 current_apps = discover_alsa_using_apps ();
2038                 if (current_apps) {
2039                         jack_error ("\n\nATTENTION: The playback device \"%s\" is "
2040                                     "already in use. The following applications "
2041                                     " are using your soundcard(s) so you should "
2042                                     " check them and stop them as necessary before "
2043                                     " trying to start JACK again:\n\n%s",
2044                                     playback_alsa_device,
2045                                     current_apps);
2046                         free (current_apps);
2047                 } else {
2048                         jack_error ("\n\nATTENTION: The playback device \"%s\" is "
2049                                     "already in use. Please stop the"
2050                                     " application using it and "
2051                                     "run JACK again",
2052                                     playback_alsa_device);
2053                 }
2054                 alsa_driver_delete (driver);
2055                                 return NULL;
2056
2057                         case EPERM:
2058                                 jack_error ("you do not have permission to open "
2059                                             "the audio device \"%s\" for playback",
2060                                             playback_alsa_device);
2061                                 alsa_driver_delete (driver);
2062                                 return NULL;
2063                                 break;
2064                         }
2065
2066                         driver->playback_handle = NULL;
2067                 }
2068
2069                 if (driver->playback_handle) {
2070                         snd_pcm_nonblock (driver->playback_handle, 0);
2071                 }
2072         }
2073
2074         if (capturing) {
2075                 if (snd_pcm_open (&driver->capture_handle,
2076                                   capture_alsa_device,
2077                                   SND_PCM_STREAM_CAPTURE,
2078                                   SND_PCM_NONBLOCK) < 0) {
2079                         switch (errno) {
2080                         case EBUSY:
2081                 current_apps = discover_alsa_using_apps ();
2082                 if (current_apps) {
2083                         jack_error ("\n\nATTENTION: The capture device \"%s\" is "
2084                                     "already in use. The following applications "
2085                                     " are using your soundcard(s) so you should "
2086                                     " check them and stop them as necessary before "
2087                                     " trying to start JACK again:\n\n%s",
2088                                     capture_alsa_device,
2089                                     current_apps);
2090                         free (current_apps);
2091                 } else {
2092                         jack_error ("\n\nATTENTION: The capture (recording) device \"%s\" is "
2093                                     "already in use. Please stop the"
2094                                     " application using it and "
2095                                     "run JACK again",
2096                                     capture_alsa_device);
2097                 }
2098                                 alsa_driver_delete (driver);
2099                                 return NULL;
2100                                 break;
2101
2102                         case EPERM:
2103                                 jack_error ("you do not have permission to open "
2104                                             "the audio device \"%s\" for capture",
2105                                             capture_alsa_device);
2106                                 alsa_driver_delete (driver);
2107                                 return NULL;
2108                                 break;
2109                         }
2110
2111                         driver->capture_handle = NULL;
2112                 }
2113
2114                 if (driver->capture_handle) {
2115                         snd_pcm_nonblock (driver->capture_handle, 0);
2116                 }
2117         }
2118
2119         if (driver->playback_handle == NULL) {
2120                 if (playing) {
2121
2122                         /* they asked for playback, but we can't do it */
2123
2124                         jack_error ("ALSA: Cannot open PCM device %s for "
2125                                     "playback. Falling back to capture-only"
2126                                     " mode", name);
2127
2128                         if (driver->capture_handle == NULL) {
2129                                 /* can't do anything */
2130                                 alsa_driver_delete (driver);
2131                                 return NULL;
2132                         }
2133
2134                         playing = FALSE;
2135                 }
2136         }
2137
2138         if (driver->capture_handle == NULL) {
2139                 if (capturing) {
2140
2141                         /* they asked for capture, but we can't do it */
2142
2143                         jack_error ("ALSA: Cannot open PCM device %s for "
2144                                     "capture. Falling back to playback-only"
2145                                     " mode", name);
2146
2147                         if (driver->playback_handle == NULL) {
2148                                 /* can't do anything */
2149                                 alsa_driver_delete (driver);
2150                                 return NULL;
2151                         }
2152
2153                         capturing = FALSE;
2154                 }
2155         }
2156
2157         driver->playback_hw_params = 0;
2158         driver->capture_hw_params = 0;
2159         driver->playback_sw_params = 0;
2160         driver->capture_sw_params = 0;
2161
2162         if (driver->playback_handle) {
2163                 if ((err = snd_pcm_hw_params_malloc (
2164                              &driver->playback_hw_params)) < 0) {
2165                         jack_error ("ALSA: could not allocate playback hw"
2166                                     " params structure");
2167                         alsa_driver_delete (driver);
2168                         return NULL;
2169                 }
2170
2171                 if ((err = snd_pcm_sw_params_malloc (
2172                              &driver->playback_sw_params)) < 0) {
2173                         jack_error ("ALSA: could not allocate playback sw"
2174                                     " params structure");
2175                         alsa_driver_delete (driver);
2176                         return NULL;
2177                 }
2178         }
2179
2180         if (driver->capture_handle) {
2181                 if ((err = snd_pcm_hw_params_malloc (
2182                              &driver->capture_hw_params)) < 0) {
2183                         jack_error ("ALSA: could not allocate capture hw"
2184                                     " params structure");
2185                         alsa_driver_delete (driver);
2186                         return NULL;
2187                 }
2188
2189                 if ((err = snd_pcm_sw_params_malloc (
2190                              &driver->capture_sw_params)) < 0) {
2191                         jack_error ("ALSA: could not allocate capture sw"
2192                                     " params structure");
2193                         alsa_driver_delete (driver);
2194                         return NULL;
2195                 }
2196         }
2197
2198         if (alsa_driver_set_parameters (driver, frames_per_cycle,
2199                                         user_nperiods, rate)) {
2200                 alsa_driver_delete (driver);
2201                 return NULL;
2202         }
2203
2204         driver->capture_and_playback_not_synced = FALSE;
2205
2206         if (driver->capture_handle && driver->playback_handle) {
2207                 if (snd_pcm_link (driver->playback_handle,
2208                                   driver->capture_handle) != 0) {
2209                         driver->capture_and_playback_not_synced = TRUE;
2210                 }
2211         }
2212
2213         driver->client = client;
2214
2215         return (jack_driver_t *) driver;
2216 }
2217
2218 int
2219 alsa_driver_listen_for_clock_sync_status (alsa_driver_t *driver,
2220                                           ClockSyncListenerFunction func,
2221                                           void *arg)
2222 {
2223         ClockSyncListener *csl;
2224
2225         csl = (ClockSyncListener *) malloc (sizeof (ClockSyncListener));
2226         csl->function = func;
2227         csl->arg = arg;
2228         csl->id = driver->next_clock_sync_listener_id++;
2229
2230         pthread_mutex_lock (&driver->clock_sync_lock);
2231         driver->clock_sync_listeners =
2232                 jack_slist_prepend (driver->clock_sync_listeners, csl);
2233         pthread_mutex_unlock (&driver->clock_sync_lock);
2234         return csl->id;
2235 }
2236
2237 int
2238 alsa_driver_stop_listening_to_clock_sync_status (alsa_driver_t *driver,
2239                                                  unsigned int which)
2240
2241 {
2242         JSList *node;
2243         int ret = -1;
2244         pthread_mutex_lock (&driver->clock_sync_lock);
2245         for (node = driver->clock_sync_listeners; node;
2246              node = jack_slist_next (node)) {
2247                 if (((ClockSyncListener *) node->data)->id == which) {
2248                         driver->clock_sync_listeners =
2249                                 jack_slist_remove_link (
2250                                         driver->clock_sync_listeners, node);
2251                         free (node->data);
2252                         jack_slist_free_1 (node);
2253                         ret = 0;
2254                         break;
2255                 }
2256         }
2257         pthread_mutex_unlock (&driver->clock_sync_lock);
2258         return ret;
2259 }
2260
2261 void
2262 alsa_driver_clock_sync_notify (alsa_driver_t *driver, channel_t chn,
2263                                ClockSyncStatus status)
2264 {
2265         JSList *node;
2266
2267         pthread_mutex_lock (&driver->clock_sync_lock);
2268         for (node = driver->clock_sync_listeners; node;
2269              node = jack_slist_next (node)) {
2270                 ClockSyncListener *csl = (ClockSyncListener *) node->data;
2271                 csl->function (chn, status, csl->arg);
2272         }
2273         pthread_mutex_unlock (&driver->clock_sync_lock);
2274
2275 }
2276
2277 /* DRIVER "PLUGIN" INTERFACE */
2278
2279 const char driver_client_name[] = "alsa_pcm";
2280
2281 void
2282 driver_finish (jack_driver_t *driver)
2283 {
2284         alsa_driver_delete ((alsa_driver_t *) driver);
2285 }