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