linux/alsa/JackAlsaDriver.cpp

   1 /*
   2 Copyright (C) 2001 Paul Davis
   3 Copyright (C) 2004 Grame
   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 #define __STDC_FORMAT_MACROS   // For inttypes.h to work in C++
  22
  23 #include <iostream>
  24 #include <math.h>
  25 #include <stdio.h>
  26 #include <memory.h>
  27 #include <unistd.h>
  28 #include <stdlib.h>
  29 #include <errno.h>
  30 #include <stdarg.h>
  31 #include <signal.h>
  32 #include <sys/types.h>
  33 #include <sys/time.h>
  34 #include <string.h>
  35
  36 #include "JackAlsaDriver.h"
  37 #include "JackEngineControl.h"
  38 #include "JackClientControl.h"
  39 #include "JackPort.h"
  40 #include "JackGraphManager.h"
  41 #include "JackLockedEngine.h"
  42 #ifdef __ANDROID__
  43 #include "JackAndroidThread.h"
  44 #else
  45 #include "JackPosixThread.h"
  46 #endif
  47 #include "JackCompilerDeps.h"
  48 #include "JackServerGlobals.h"
  49
  50 static struct jack_constraint_enum_str_descriptor midi_constraint_descr_array[] =
  51 {
  52     { "none", "no MIDI driver" },
  53     { "seq", "ALSA Sequencer driver" },
  54     { "raw", "ALSA RawMIDI driver" },
  55     { 0 }
  56 };
  57
  58 static struct jack_constraint_enum_char_descriptor dither_constraint_descr_array[] =
  59 {
  60     { 'n', "none" },
  61     { 'r', "rectangular" },
  62     { 's', "shaped" },
  63     { 't', "triangular" },
  64     { 0 }
  65 };
  66
  67 namespace Jack
  68 {
  69
  70 int JackAlsaDriver::SetBufferSize(jack_nframes_t buffer_size)
  71 {
  72     jack_log("JackAlsaDriver::SetBufferSize %ld", buffer_size);
  73     int res = alsa_driver_reset_parameters((alsa_driver_t *)fDriver, buffer_size,
  74                                            ((alsa_driver_t *)fDriver)->user_nperiods,
  75                                            ((alsa_driver_t *)fDriver)->frame_rate);
  76
  77     if (res == 0) { // update fEngineControl and fGraphManager
  78         JackAudioDriver::SetBufferSize(buffer_size);  // Generic change, never fails
  79         // ALSA specific
  80         UpdateLatencies();
  81     } else {
  82         // Restore old values
  83         alsa_driver_reset_parameters((alsa_driver_t *)fDriver, fEngineControl->fBufferSize,
  84                                      ((alsa_driver_t *)fDriver)->user_nperiods,
  85                                      ((alsa_driver_t *)fDriver)->frame_rate);
  86     }
  87
  88     return res;
  89 }
  90
  91 void JackAlsaDriver::UpdateLatencies()
  92 {
  93     jack_latency_range_t range;
  94     alsa_driver_t* alsa_driver = (alsa_driver_t*)fDriver;
  95
  96     for (int i = 0; i < fCaptureChannels; i++) {
  97         range.min = range.max = alsa_driver->frames_per_cycle + alsa_driver->capture_frame_latency;
  98         fGraphManager->GetPort(fCapturePortList[i])->SetLatencyRange(JackCaptureLatency, &range);
  99     }
 100
 101     for (int i = 0; i < fPlaybackChannels; i++) {
 102         // Add one buffer more latency if "async" mode is used...
 103         range.min = range.max = (alsa_driver->frames_per_cycle * (alsa_driver->user_nperiods - 1)) +
 104                          ((fEngineControl->fSyncMode) ? 0 : fEngineControl->fBufferSize) + alsa_driver->playback_frame_latency;
 105         fGraphManager->GetPort(fPlaybackPortList[i])->SetLatencyRange(JackPlaybackLatency, &range);
 106         // Monitor port
 107         if (fWithMonitorPorts) {
 108             range.min = range.max = alsa_driver->frames_per_cycle;
 109             fGraphManager->GetPort(fMonitorPortList[i])->SetLatencyRange(JackCaptureLatency, &range);
 110         }
 111     }
 112 }
 113
 114 int JackAlsaDriver::Attach()
 115 {
 116     JackPort* port;
 117     jack_port_id_t port_index;
 118     unsigned long port_flags = (unsigned long)CaptureDriverFlags;
 119     char name[REAL_JACK_PORT_NAME_SIZE];
 120     char alias[REAL_JACK_PORT_NAME_SIZE];
 121
 122     assert(fCaptureChannels < DRIVER_PORT_NUM);
 123     assert(fPlaybackChannels < DRIVER_PORT_NUM);
 124
 125     alsa_driver_t* alsa_driver = (alsa_driver_t*)fDriver;
 126
 127     if (alsa_driver->has_hw_monitoring)
 128         port_flags |= JackPortCanMonitor;
 129
 130     // ALSA driver may have changed the values
 131     JackAudioDriver::SetBufferSize(alsa_driver->frames_per_cycle);
 132     JackAudioDriver::SetSampleRate(alsa_driver->frame_rate);
 133
 134     jack_log("JackAlsaDriver::Attach fBufferSize %ld fSampleRate %ld", fEngineControl->fBufferSize, fEngineControl->fSampleRate);
 135
 136     for (int i = 0; i < fCaptureChannels; i++) {
 137         snprintf(alias, sizeof(alias), "%s:%s:out%d", fAliasName, fCaptureDriverName, i + 1);
 138         snprintf(name, sizeof(name), "%s:capture_%d", fClientControl.fName, i + 1);
 139         if (fEngine->PortRegister(fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE, (JackPortFlags)port_flags, fEngineControl->fBufferSize, &port_index) < 0) {
 140             jack_error("driver: cannot register port for %s", name);
 141             return -1;
 142         }
 143         port = fGraphManager->GetPort(port_index);
 144         port->SetAlias(alias);
 145         fCapturePortList[i] = port_index;
 146         jack_log("JackAlsaDriver::Attach fCapturePortList[i] %ld ", port_index);
 147     }
 148
 149     port_flags = (unsigned long)PlaybackDriverFlags;
 150
 151     for (int i = 0; i < fPlaybackChannels; i++) {
 152         snprintf(alias, sizeof(alias), "%s:%s:in%d", fAliasName, fPlaybackDriverName, i + 1);
 153         snprintf(name, sizeof(name), "%s:playback_%d", fClientControl.fName, i + 1);
 154         if (fEngine->PortRegister(fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE, (JackPortFlags)port_flags, fEngineControl->fBufferSize, &port_index) < 0) {
 155             jack_error("driver: cannot register port for %s", name);
 156             return -1;
 157         }
 158         port = fGraphManager->GetPort(port_index);
 159         port->SetAlias(alias);
 160         fPlaybackPortList[i] = port_index;
 161         jack_log("JackAlsaDriver::Attach fPlaybackPortList[i] %ld ", port_index);
 162
 163         // Monitor ports
 164         if (fWithMonitorPorts) {
 165             jack_log("Create monitor port");
 166             snprintf(name, sizeof(name), "%s:monitor_%d", fClientControl.fName, i + 1);
 167             if (fEngine->PortRegister(fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE, MonitorDriverFlags, fEngineControl->fBufferSize, &port_index) < 0) {
 168                 jack_error("ALSA: cannot register monitor port for %s", name);
 169             } else {
 170                 fMonitorPortList[i] = port_index;
 171             }
 172         }
 173     }
 174
 175     UpdateLatencies();
 176
 177     if (alsa_driver->midi) {
 178         int err = (alsa_driver->midi->attach)(alsa_driver->midi);
 179         if (err)
 180             jack_error ("ALSA: cannot attach MIDI: %d", err);
 181     }
 182
 183     return 0;
 184 }
 185
 186 int JackAlsaDriver::Detach()
 187 {
 188     alsa_driver_t* alsa_driver = (alsa_driver_t*)fDriver;
 189     if (alsa_driver->midi)
 190         (alsa_driver->midi->detach)(alsa_driver->midi);
 191
 192     return JackAudioDriver::Detach();
 193 }
 194
 195 extern "C" char* get_control_device_name(const char * device_name)
 196 {
 197     char * ctl_name;
 198     const char * comma;
 199
 200     /* the user wants a hw or plughw device, the ctl name
 201      * should be hw:x where x is the card identification.
 202      * We skip the subdevice suffix that starts with comma */
 203
 204     if (strncasecmp(device_name, "plughw:", 7) == 0) {
 205         /* skip the "plug" prefix" */
 206         device_name += 4;
 207     }
 208
 209     comma = strchr(device_name, ',');
 210     if (comma == NULL) {
 211         ctl_name = strdup(device_name);
 212         if (ctl_name == NULL) {
 213             jack_error("strdup(\"%s\") failed.", device_name);
 214         }
 215     } else {
 216         ctl_name = strndup(device_name, comma - device_name);
 217         if (ctl_name == NULL) {
 218             jack_error("strndup(\"%s\", %u) failed.", device_name, (unsigned int)(comma - device_name));
 219         }
 220     }
 221
 222     return ctl_name;
 223 }
 224
 225 static int card_to_num(const char* device)
 226 {
 227     int err;
 228     char* ctl_name;
 229     snd_ctl_card_info_t *card_info;
 230     snd_ctl_t* ctl_handle;
 231     int i = -1;
 232
 233     snd_ctl_card_info_alloca (&card_info);
 234
 235     ctl_name = get_control_device_name(device);
 236     if (ctl_name == NULL) {
 237         jack_error("get_control_device_name() failed.");
 238         goto fail;
 239     }
 240
 241     if ((err = snd_ctl_open (&ctl_handle, ctl_name, 0)) < 0) {
 242         jack_error ("control open \"%s\" (%s)", ctl_name,
 243                     snd_strerror(err));
 244         goto free;
 245     }
 246
 247     if ((err = snd_ctl_card_info(ctl_handle, card_info)) < 0) {
 248         jack_error ("control hardware info \"%s\" (%s)",
 249                     device, snd_strerror (err));
 250         goto close;
 251     }
 252
 253     i = snd_ctl_card_info_get_card(card_info);
 254
 255 close:
 256     snd_ctl_close(ctl_handle);
 257
 258 free:
 259     free(ctl_name);
 260
 261 fail:
 262     return i;
 263 }
 264
 265 int JackAlsaDriver::Open(jack_nframes_t nframes,
 266                          jack_nframes_t user_nperiods,
 267                          jack_nframes_t samplerate,
 268                          bool hw_monitoring,
 269                          bool hw_metering,
 270                          bool capturing,
 271                          bool playing,
 272                          DitherAlgorithm dither,
 273                          bool soft_mode,
 274                          bool monitor,
 275                          int inchannels,
 276                          int outchannels,
 277                          bool shorts_first,
 278                          const char* capture_driver_name,
 279                          const char* playback_driver_name,
 280                          jack_nframes_t capture_latency,
 281                          jack_nframes_t playback_latency,
 282                          const char* midi_driver_name)
 283 {
 284     // Generic JackAudioDriver Open
 285     if (JackAudioDriver::Open(nframes, samplerate, capturing, playing,
 286                               inchannels, outchannels, monitor, capture_driver_name, playback_driver_name,
 287                               capture_latency, playback_latency) != 0) {
 288         return -1;
 289     }
 290
 291     alsa_midi_t *midi = 0;
 292 #ifndef __ANDROID__
 293     if (strcmp(midi_driver_name, "seq") == 0)
 294         midi = alsa_seqmidi_new((jack_client_t*)this, 0);
 295     else if (strcmp(midi_driver_name, "raw") == 0)
 296         midi = alsa_rawmidi_new((jack_client_t*)this);
 297 #endif
 298
 299     if (JackServerGlobals::on_device_acquire != NULL) {
 300         int capture_card = card_to_num(capture_driver_name);
 301         int playback_card = card_to_num(playback_driver_name);
 302         char audio_name[32];
 303
 304         if (capture_card >= 0) {
 305             snprintf(audio_name, sizeof(audio_name), "Audio%d", capture_card);
 306             if (!JackServerGlobals::on_device_acquire(audio_name)) {
 307                 jack_error("Audio device %s cannot be acquired...", capture_driver_name);
 308                 return -1;
 309             }
 310         }
 311
 312         if (playback_card >= 0 && playback_card != capture_card) {
 313             snprintf(audio_name, sizeof(audio_name), "Audio%d", playback_card);
 314             if (!JackServerGlobals::on_device_acquire(audio_name)) {
 315                 jack_error("Audio device %s cannot be acquired...", playback_driver_name);
 316                 if (capture_card >= 0) {
 317                     snprintf(audio_name, sizeof(audio_name), "Audio%d", capture_card);
 318                     JackServerGlobals::on_device_release(audio_name);
 319                 }
 320                 return -1;
 321             }
 322         }
 323     }
 324
 325     fDriver = alsa_driver_new ((char*)"alsa_pcm", (char*)playback_driver_name, (char*)capture_driver_name,
 326                                NULL,
 327                                nframes,
 328                                user_nperiods,
 329                                samplerate,
 330                                hw_monitoring,
 331                                hw_metering,
 332                                capturing,
 333                                playing,
 334                                dither,
 335                                soft_mode,
 336                                monitor,
 337                                inchannels,
 338                                outchannels,
 339                                shorts_first,
 340                                capture_latency,
 341                                playback_latency,
 342                                midi);
 343     if (fDriver) {
 344         // ALSA driver may have changed the in/out values
 345         fCaptureChannels = ((alsa_driver_t *)fDriver)->capture_nchannels;
 346         fPlaybackChannels = ((alsa_driver_t *)fDriver)->playback_nchannels;
 347         return 0;
 348     } else {
 349         JackAudioDriver::Close();
 350         return -1;
 351     }
 352 }
 353
 354 int JackAlsaDriver::Close()
 355 {
 356     // Generic audio driver close
 357     int res = JackAudioDriver::Close();
 358
 359     alsa_driver_delete((alsa_driver_t*)fDriver);
 360
 361     if (JackServerGlobals::on_device_release != NULL)
 362     {
 363         char audio_name[32];
 364         int capture_card = card_to_num(fCaptureDriverName);
 365         if (capture_card >= 0) {
 366             snprintf(audio_name, sizeof(audio_name), "Audio%d", capture_card);
 367             JackServerGlobals::on_device_release(audio_name);
 368         }
 369
 370         int playback_card = card_to_num(fPlaybackDriverName);
 371         if (playback_card >= 0 && playback_card != capture_card) {
 372             snprintf(audio_name, sizeof(audio_name), "Audio%d", playback_card);
 373             JackServerGlobals::on_device_release(audio_name);
 374         }
 375     }
 376
 377     return res;
 378 }
 379
 380 int JackAlsaDriver::Start()
 381 {
 382     int res = JackAudioDriver::Start();
 383     if (res >= 0) {
 384         res = alsa_driver_start((alsa_driver_t *)fDriver);
 385         if (res < 0) {
 386             JackAudioDriver::Stop();
 387         }
 388     }
 389     return res;
 390 }
 391
 392 int JackAlsaDriver::Stop()
 393 {
 394     int res = alsa_driver_stop((alsa_driver_t *)fDriver);
 395     if (JackAudioDriver::Stop() < 0) {
 396         res = -1;
 397     }
 398     return res;
 399 }
 400
 401 int JackAlsaDriver::Read()
 402 {
 403     /* Taken from alsa_driver_run_cycle */
 404     int wait_status;
 405     jack_nframes_t nframes;
 406     fDelayedUsecs = 0.f;
 407
 408 retry:
 409
 410     nframes = alsa_driver_wait((alsa_driver_t *)fDriver, -1, &wait_status, &fDelayedUsecs);
 411
 412     if (wait_status < 0)
 413         return -1;              /* driver failed */
 414
 415     if (nframes == 0) {
 416         /* we detected an xrun and restarted: notify
 417          * clients about the delay.
 418          */
 419         jack_log("ALSA XRun wait_status = %d", wait_status);
 420         NotifyXRun(fBeginDateUst, fDelayedUsecs);
 421         goto retry; /* recoverable error*/
 422     }
 423
 424     if (nframes != fEngineControl->fBufferSize)
 425         jack_log("JackAlsaDriver::Read warning fBufferSize = %ld nframes = %ld", fEngineControl->fBufferSize, nframes);
 426
 427     // Has to be done before read
 428     JackDriver::CycleIncTime();
 429
 430     return alsa_driver_read((alsa_driver_t *)fDriver, fEngineControl->fBufferSize);
 431 }
 432
 433 int JackAlsaDriver::Write()
 434 {
 435     return alsa_driver_write((alsa_driver_t *)fDriver, fEngineControl->fBufferSize);
 436 }
 437
 438 void JackAlsaDriver::ReadInputAux(jack_nframes_t orig_nframes, snd_pcm_sframes_t contiguous, snd_pcm_sframes_t nread)
 439 {
 440     for (int chn = 0; chn < fCaptureChannels; chn++) {
 441         if (fGraphManager->GetConnectionsNum(fCapturePortList[chn]) > 0) {
 442             jack_default_audio_sample_t* buf = (jack_default_audio_sample_t*)fGraphManager->GetBuffer(fCapturePortList[chn], orig_nframes);
 443             alsa_driver_read_from_channel((alsa_driver_t *)fDriver, chn, buf + nread, contiguous);
 444         }
 445     }
 446 }
 447
 448 void JackAlsaDriver::MonitorInputAux()
 449 {
 450     for (int chn = 0; chn < fCaptureChannels; chn++) {
 451         JackPort* port = fGraphManager->GetPort(fCapturePortList[chn]);
 452         if (port->MonitoringInput()) {
 453             ((alsa_driver_t *)fDriver)->input_monitor_mask |= (1 << chn);
 454         }
 455     }
 456 }
 457
 458 void JackAlsaDriver::ClearOutputAux()
 459 {
 460     for (int chn = 0; chn < fPlaybackChannels; chn++) {
 461         jack_default_audio_sample_t* buf =
 462             (jack_default_audio_sample_t*)fGraphManager->GetBuffer(fPlaybackPortList[chn], fEngineControl->fBufferSize);
 463         memset(buf, 0, sizeof (jack_default_audio_sample_t) * fEngineControl->fBufferSize);
 464     }
 465 }
 466
 467 void JackAlsaDriver::SetTimetAux(jack_time_t time)
 468 {
 469     fBeginDateUst = time;
 470 }
 471
 472 void JackAlsaDriver::WriteOutputAux(jack_nframes_t orig_nframes, snd_pcm_sframes_t contiguous, snd_pcm_sframes_t nwritten)
 473 {
 474     for (int chn = 0; chn < fPlaybackChannels; chn++) {
 475         // Output ports
 476         if (fGraphManager->GetConnectionsNum(fPlaybackPortList[chn]) > 0) {
 477             jack_default_audio_sample_t* buf = (jack_default_audio_sample_t*)fGraphManager->GetBuffer(fPlaybackPortList[chn], orig_nframes);
 478             alsa_driver_write_to_channel(((alsa_driver_t *)fDriver), chn, buf + nwritten, contiguous);
 479             // Monitor ports
 480             if (fWithMonitorPorts && fGraphManager->GetConnectionsNum(fMonitorPortList[chn]) > 0) {
 481                 jack_default_audio_sample_t* monbuf = (jack_default_audio_sample_t*)fGraphManager->GetBuffer(fMonitorPortList[chn], orig_nframes);
 482                 memcpy(monbuf + nwritten, buf + nwritten, contiguous * sizeof(jack_default_audio_sample_t));
 483             }
 484         }
 485     }
 486 }
 487
 488 int JackAlsaDriver::is_realtime() const
 489 {
 490     return fEngineControl->fRealTime;
 491 }
 492
 493 int JackAlsaDriver::create_thread(pthread_t *thread, int priority, int realtime, void *(*start_routine)(void*), void *arg)
 494 {
 495 #ifdef __ANDROID__
 496     return JackAndroidThread::StartImp(thread, priority, realtime, start_routine, arg);
 497 #else
 498     return JackPosixThread::StartImp(thread, priority, realtime, start_routine, arg);
 499 #endif
 500 }
 501
 502 jack_port_id_t JackAlsaDriver::port_register(const char *port_name, const char *port_type, unsigned long flags, unsigned long buffer_size)
 503 {
 504     jack_port_id_t port_index;
 505     int res = fEngine->PortRegister(fClientControl.fRefNum, port_name, port_type, flags, buffer_size, &port_index);
 506     return (res == 0) ? port_index : 0;
 507 }
 508
 509 int JackAlsaDriver::port_unregister(jack_port_id_t port_index)
 510 {
 511     return fEngine->PortUnRegister(fClientControl.fRefNum, port_index);
 512 }
 513
 514 void* JackAlsaDriver::port_get_buffer(int port, jack_nframes_t nframes)
 515 {
 516     return fGraphManager->GetBuffer(port, nframes);
 517 }
 518
 519 int  JackAlsaDriver::port_set_alias(int port, const char* name)
 520 {
 521     return fGraphManager->GetPort(port)->SetAlias(name);
 522 }
 523
 524 jack_nframes_t JackAlsaDriver::get_sample_rate() const
 525 {
 526     return fEngineControl->fSampleRate;
 527 }
 528
 529 jack_nframes_t JackAlsaDriver::frame_time() const
 530 {
 531     JackTimer timer;
 532     fEngineControl->ReadFrameTime(&timer);
 533     return timer.Time2Frames(GetMicroSeconds(), fEngineControl->fBufferSize);
 534 }
 535
 536 jack_nframes_t JackAlsaDriver::last_frame_time() const
 537 {
 538     JackTimer timer;
 539     fEngineControl->ReadFrameTime(&timer);
 540     return timer.CurFrame();
 541 }
 542
 543 } // end of namespace
 544
 545
 546 #ifdef __cplusplus
 547 extern "C"
 548 {
 549 #endif
 550
 551 static
 552 jack_driver_param_constraint_desc_t *
 553 enum_alsa_devices()
 554 {
 555     snd_ctl_t * handle;
 556     snd_ctl_card_info_t * info;
 557     snd_pcm_info_t * pcminfo_capture;
 558     snd_pcm_info_t * pcminfo_playback;
 559     int card_no = -1;
 560     jack_driver_param_value_t card_id;
 561     jack_driver_param_value_t device_id;
 562     char description[64];
 563     int device_no;
 564     bool has_capture;
 565     bool has_playback;
 566     jack_driver_param_constraint_desc_t * constraint_ptr;
 567     uint32_t array_size = 0;
 568
 569     snd_ctl_card_info_alloca(&info);
 570     snd_pcm_info_alloca(&pcminfo_capture);
 571     snd_pcm_info_alloca(&pcminfo_playback);
 572
 573     constraint_ptr = NULL;
 574
 575     while(snd_card_next(&card_no) >= 0 && card_no >= 0)
 576     {
 577         snprintf(card_id.str, sizeof(card_id.str), "hw:%d", card_no);
 578
 579         if (snd_ctl_open(&handle, card_id.str, 0) >= 0 &&
 580             snd_ctl_card_info(handle, info) >= 0)
 581         {
 582             snprintf(card_id.str, sizeof(card_id.str), "hw:%s", snd_ctl_card_info_get_id(info));
 583             if (!jack_constraint_add_enum(
 584                     &constraint_ptr,
 585                     &array_size,
 586                     &card_id,
 587                     snd_ctl_card_info_get_name(info)))
 588                 goto fail;
 589
 590             device_no = -1;
 591
 592             while (snd_ctl_pcm_next_device(handle, &device_no) >= 0 && device_no != -1)
 593             {
 594                 snprintf(device_id.str, sizeof(device_id.str), "%s,%d", card_id.str, device_no);
 595
 596                 snd_pcm_info_set_device(pcminfo_capture, device_no);
 597                 snd_pcm_info_set_subdevice(pcminfo_capture, 0);
 598                 snd_pcm_info_set_stream(pcminfo_capture, SND_PCM_STREAM_CAPTURE);
 599                 has_capture = snd_ctl_pcm_info(handle, pcminfo_capture) >= 0;
 600
 601                 snd_pcm_info_set_device(pcminfo_playback, device_no);
 602                 snd_pcm_info_set_subdevice(pcminfo_playback, 0);
 603                 snd_pcm_info_set_stream(pcminfo_playback, SND_PCM_STREAM_PLAYBACK);
 604                 has_playback = snd_ctl_pcm_info(handle, pcminfo_playback) >= 0;
 605
 606                 if (has_capture && has_playback)
 607                 {
 608                     snprintf(description, sizeof(description),"%s (duplex)", snd_pcm_info_get_name(pcminfo_capture));
 609                 }
 610                 else if (has_capture)
 611                 {
 612                     snprintf(description, sizeof(description),"%s (capture)", snd_pcm_info_get_name(pcminfo_capture));
 613                 }
 614                 else if (has_playback)
 615                 {
 616                     snprintf(description, sizeof(description),"%s (playback)", snd_pcm_info_get_name(pcminfo_playback));
 617                 }
 618                 else
 619                 {
 620                     continue;
 621                 }
 622
 623                 if (!jack_constraint_add_enum(
 624                         &constraint_ptr,
 625                         &array_size,
 626                         &device_id,
 627                         description))
 628                     goto fail;
 629             }
 630
 631             snd_ctl_close(handle);
 632         }
 633     }
 634
 635     return constraint_ptr;
 636 fail:
 637     jack_constraint_free(constraint_ptr);
 638     return NULL;
 639 }
 640
 641 static int
 642 dither_opt (char c, DitherAlgorithm* dither)
 643 {
 644     switch (c) {
 645         case '-':
 646         case 'n':
 647             *dither = None;
 648             break;
 649
 650         case 'r':
 651             *dither = Rectangular;
 652             break;
 653
 654         case 's':
 655             *dither = Shaped;
 656             break;
 657
 658         case 't':
 659             *dither = Triangular;
 660             break;
 661
 662         default:
 663             fprintf (stderr, "ALSA driver: illegal dithering mode %c\n", c);
 664             return -1;
 665     }
 666     return 0;
 667 }
 668
 669 SERVER_EXPORT const jack_driver_desc_t* driver_get_descriptor ()
 670 {
 671     jack_driver_desc_t * desc;
 672     jack_driver_desc_filler_t filler;
 673     jack_driver_param_value_t value;
 674
 675     desc = jack_driver_descriptor_construct("alsa", JackDriverMaster, "Linux ALSA API based audio backend", &filler);
 676
 677     strcpy(value.str, "hw:0");
 678 #ifdef __ANDROID__
 679     jack_driver_descriptor_add_parameter(desc, &filler, "device", 'd', JackDriverParamString, &value, NULL, "ALSA device name", NULL);
 680 #else
 681     jack_driver_descriptor_add_parameter(desc, &filler, "device", 'd', JackDriverParamString, &value, enum_alsa_devices(), "ALSA device name", NULL);
 682 #endif
 683
 684     strcpy(value.str, "none");
 685     jack_driver_descriptor_add_parameter(desc, &filler, "capture", 'C', JackDriverParamString, &value, NULL, "Provide capture ports.  Optionally set device", NULL);
 686     jack_driver_descriptor_add_parameter(desc, &filler, "playback", 'P', JackDriverParamString, &value, NULL, "Provide playback ports.  Optionally set device", NULL);
 687
 688     value.ui = 48000U;
 689     jack_driver_descriptor_add_parameter(desc, &filler, "rate", 'r', JackDriverParamUInt, &value, NULL, "Sample rate", NULL);
 690
 691     value.ui = 1024U;
 692     jack_driver_descriptor_add_parameter(desc, &filler, "period", 'p', JackDriverParamUInt, &value, NULL, "Frames per period", NULL);
 693
 694     value.ui = 2U;
 695     jack_driver_descriptor_add_parameter(desc, &filler, "nperiods", 'n', JackDriverParamUInt, &value, NULL, "Number of periods of playback latency", NULL);
 696
 697     value.i = 0;
 698     jack_driver_descriptor_add_parameter(desc, &filler, "hwmon", 'H', JackDriverParamBool, &value, NULL, "Hardware monitoring, if available", NULL);
 699
 700     value.i = 0;
 701     jack_driver_descriptor_add_parameter(desc, &filler, "hwmeter", 'M', JackDriverParamBool, &value, NULL, "Hardware metering, if available", NULL);
 702
 703     value.i = 1;
 704     jack_driver_descriptor_add_parameter(desc, &filler, "duplex", 'D', JackDriverParamBool, &value, NULL, "Provide both capture and playback ports", NULL);
 705
 706     value.i = 0;
 707     jack_driver_descriptor_add_parameter(desc, &filler, "softmode", 's', JackDriverParamBool, &value, NULL, "Soft-mode, no xrun handling", NULL);
 708
 709     value.i = 0;
 710     jack_driver_descriptor_add_parameter(desc, &filler, "monitor", 'm', JackDriverParamBool, &value, NULL, "Provide monitor ports for the output", NULL);
 711
 712     value.c = 'n';
 713     jack_driver_descriptor_add_parameter(
 714         desc,
 715         &filler,
 716         "dither",
 717         'z',
 718         JackDriverParamChar,
 719         &value,
 720         jack_constraint_compose_enum_char(
 721             JACK_CONSTRAINT_FLAG_STRICT | JACK_CONSTRAINT_FLAG_FAKE_VALUE,
 722             dither_constraint_descr_array),
 723         "Dithering mode",
 724         NULL);
 725
 726     value.ui = 0;
 727     jack_driver_descriptor_add_parameter(desc, &filler, "inchannels", 'i', JackDriverParamUInt, &value, NULL, "Number of capture channels (defaults to hardware max)", NULL);
 728     jack_driver_descriptor_add_parameter(desc, &filler, "outchannels", 'o', JackDriverParamUInt, &value, NULL, "Number of playback channels (defaults to hardware max)", NULL);
 729
 730     value.i = FALSE;
 731     jack_driver_descriptor_add_parameter(desc, &filler, "shorts", 'S', JackDriverParamBool, &value, NULL, "Try 16-bit samples before 32-bit", NULL);
 732
 733     value.ui = 0;
 734     jack_driver_descriptor_add_parameter(desc, &filler, "input-latency", 'I', JackDriverParamUInt, &value, NULL, "Extra input latency (frames)", NULL);
 735     jack_driver_descriptor_add_parameter(desc, &filler, "output-latency", 'O', JackDriverParamUInt, &value, NULL, "Extra output latency (frames)", NULL);
 736
 737     strcpy(value.str, "none");
 738     jack_driver_descriptor_add_parameter(
 739         desc,
 740         &filler,
 741         "midi-driver",
 742         'X',
 743         JackDriverParamString,
 744         &value,
 745         jack_constraint_compose_enum_str(
 746             JACK_CONSTRAINT_FLAG_STRICT | JACK_CONSTRAINT_FLAG_FAKE_VALUE,
 747             midi_constraint_descr_array),
 748         "ALSA MIDI driver",
 749         NULL);
 750
 751     return desc;
 752 }
 753
 754 static Jack::JackAlsaDriver* g_alsa_driver;
 755
 756 SERVER_EXPORT Jack::JackDriverClientInterface* driver_initialize(Jack::JackLockedEngine* engine, Jack::JackSynchro* table, const JSList* params)
 757 {
 758     jack_nframes_t srate = 48000;
 759     jack_nframes_t frames_per_interrupt = 1024;
 760     unsigned long user_nperiods = 2;
 761     const char *playback_pcm_name = "hw:0";
 762     const char *capture_pcm_name = "hw:0";
 763     int hw_monitoring = FALSE;
 764     int hw_metering = FALSE;
 765     int capture = FALSE;
 766     int playback = FALSE;
 767     int soft_mode = FALSE;
 768     int monitor = FALSE;
 769     DitherAlgorithm dither = None;
 770     int user_capture_nchnls = 0;
 771     int user_playback_nchnls = 0;
 772     int shorts_first = FALSE;
 773     jack_nframes_t systemic_input_latency = 0;
 774     jack_nframes_t systemic_output_latency = 0;
 775     const JSList * node;
 776     const jack_driver_param_t * param;
 777     const char *midi_driver = "none";
 778
 779     for (node = params; node; node = jack_slist_next (node)) {
 780         param = (const jack_driver_param_t *) node->data;
 781
 782         switch (param->character) {
 783
 784             case 'C':
 785                 capture = TRUE;
 786                 if (strcmp (param->value.str, "none") != 0) {
 787                     capture_pcm_name = strdup (param->value.str);
 788                     jack_log("capture device %s", capture_pcm_name);
 789                 }
 790                 break;
 791
 792             case 'P':
 793                 playback = TRUE;
 794                 if (strcmp (param->value.str, "none") != 0) {
 795                     playback_pcm_name = strdup (param->value.str);
 796                     jack_log("playback device %s", playback_pcm_name);
 797                 }
 798                 break;
 799
 800             case 'D':
 801                 playback = TRUE;
 802                 capture = TRUE;
 803                 break;
 804
 805             case 'd':
 806                 if (strcmp (param->value.str, "none") != 0) {
 807                     playback_pcm_name = strdup (param->value.str);
 808                     capture_pcm_name = strdup (param->value.str);
 809                     jack_log("playback device %s", playback_pcm_name);
 810                     jack_log("capture device %s", capture_pcm_name);
 811                 }
 812                 break;
 813
 814             case 'H':
 815                 hw_monitoring = param->value.i;
 816                 break;
 817
 818             case 'm':
 819                 monitor = param->value.i;
 820                 break;
 821
 822             case 'M':
 823                 hw_metering = param->value.i;
 824                 break;
 825
 826             case 'r':
 827                 srate = param->value.ui;
 828                 jack_log("apparent rate = %d", srate);
 829                 break;
 830
 831             case 'p':
 832                 frames_per_interrupt = param->value.ui;
 833                 jack_log("frames per period = %d", frames_per_interrupt);
 834                 break;
 835
 836             case 'n':
 837                 user_nperiods = param->value.ui;
 838                 if (user_nperiods < 2) {    /* enforce minimum value */
 839                     user_nperiods = 2;
 840                 }
 841                 break;
 842
 843             case 's':
 844                 soft_mode = param->value.i;
 845                 break;
 846
 847             case 'z':
 848                 if (dither_opt (param->value.c, &dither)) {
 849                     return NULL;
 850                 }
 851                 break;
 852
 853             case 'i':
 854                 user_capture_nchnls = param->value.ui;
 855                 break;
 856
 857             case 'o':
 858                 user_playback_nchnls = param->value.ui;
 859                 break;
 860
 861             case 'S':
 862                 shorts_first = param->value.i;
 863                 break;
 864
 865             case 'I':
 866                 systemic_input_latency = param->value.ui;
 867                 break;
 868
 869             case 'O':
 870                 systemic_output_latency = param->value.ui;
 871                 break;
 872
 873             case 'X':
 874                 midi_driver = strdup(param->value.str);
 875                 break;
 876         }
 877     }
 878
 879     /* duplex is the default */
 880     if (!capture && !playback) {
 881         capture = TRUE;
 882         playback = TRUE;
 883     }
 884
 885     g_alsa_driver = new Jack::JackAlsaDriver("system", "alsa_pcm", engine, table);
 886     Jack::JackDriverClientInterface* threaded_driver = new Jack::JackThreadedDriver(g_alsa_driver);
 887     // Special open for ALSA driver...
 888     if (g_alsa_driver->Open(frames_per_interrupt, user_nperiods, srate, hw_monitoring, hw_metering, capture, playback, dither, soft_mode, monitor,
 889                           user_capture_nchnls, user_playback_nchnls, shorts_first, capture_pcm_name, playback_pcm_name,
 890                           systemic_input_latency, systemic_output_latency, midi_driver) == 0) {
 891         return threaded_driver;
 892     } else {
 893         delete threaded_driver; // Delete the decorated driver
 894         return NULL;
 895     }
 896 }
 897
 898 // Code to be used in alsa_driver.c
 899
 900 void ReadInput(jack_nframes_t orig_nframes, snd_pcm_sframes_t contiguous, snd_pcm_sframes_t nread)
 901 {
 902     g_alsa_driver->ReadInputAux(orig_nframes, contiguous, nread);
 903 }
 904 void MonitorInput()
 905 {
 906     g_alsa_driver->MonitorInputAux();
 907 }
 908 void ClearOutput()
 909 {
 910     g_alsa_driver->ClearOutputAux();
 911 }
 912 void WriteOutput(jack_nframes_t orig_nframes, snd_pcm_sframes_t contiguous, snd_pcm_sframes_t nwritten)
 913 {
 914     g_alsa_driver->WriteOutputAux(orig_nframes, contiguous, nwritten);
 915 }
 916 void SetTime(jack_time_t time)
 917 {
 918     g_alsa_driver->SetTimetAux(time);
 919 }
 920
 921 int Restart()
 922 {
 923     int res;
 924     if ((res = g_alsa_driver->Stop()) == 0) {
 925         res = g_alsa_driver->Start();
 926     }
 927     return res;
 928 }
 929
 930 #ifdef __cplusplus
 931 }
 932 #endif
 933
 934