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