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