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