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