2 Copyright (C) 2001 Paul Davis
3 Copyright (C) 2004 Grame
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.
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.
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.
21 #define __STDC_FORMAT_MACROS // For inttypes.h to work in C++
32 #include <sys/types.h>
36 #include "JackAlsaDriver.h"
37 #include "JackEngineControl.h"
38 #include "JackClientControl.h"
40 #include "JackGraphManager.h"
41 #include "JackLockedEngine.h"
42 #include "JackPosixThread.h"
43 #include "JackCompilerDeps.h"
44 #include "JackServerGlobals.h"
49 int JackAlsaDriver::SetBufferSize(jack_nframes_t buffer_size
)
51 jack_log("JackAlsaDriver::SetBufferSize %ld", buffer_size
);
52 int res
= alsa_driver_reset_parameters((alsa_driver_t
*)fDriver
, buffer_size
,
53 ((alsa_driver_t
*)fDriver
)->user_nperiods
,
54 ((alsa_driver_t
*)fDriver
)->frame_rate
);
56 if (res
== 0) { // update fEngineControl and fGraphManager
57 JackAudioDriver::SetBufferSize(buffer_size
); // Generic change, never fails
62 alsa_driver_reset_parameters((alsa_driver_t
*)fDriver
, fEngineControl
->fBufferSize
,
63 ((alsa_driver_t
*)fDriver
)->user_nperiods
,
64 ((alsa_driver_t
*)fDriver
)->frame_rate
);
70 void JackAlsaDriver::UpdateLatencies()
72 jack_latency_range_t range
;
73 alsa_driver_t
* alsa_driver
= (alsa_driver_t
*)fDriver
;
75 for (int i
= 0; i
< fCaptureChannels
; i
++) {
76 range
.min
= range
.max
= alsa_driver
->frames_per_cycle
+ alsa_driver
->capture_frame_latency
;
77 fGraphManager
->GetPort(fCapturePortList
[i
])->SetLatencyRange(JackCaptureLatency
, &range
);
80 for (int i
= 0; i
< fPlaybackChannels
; i
++) {
81 // Add one buffer more latency if "async" mode is used...
82 range
.min
= range
.max
= (alsa_driver
->frames_per_cycle
* (alsa_driver
->user_nperiods
- 1)) +
83 ((fEngineControl
->fSyncMode
) ? 0 : fEngineControl
->fBufferSize
) + alsa_driver
->playback_frame_latency
;
84 fGraphManager
->GetPort(fPlaybackPortList
[i
])->SetLatencyRange(JackPlaybackLatency
, &range
);
86 if (fWithMonitorPorts
) {
87 range
.min
= range
.max
= alsa_driver
->frames_per_cycle
;
88 fGraphManager
->GetPort(fMonitorPortList
[i
])->SetLatencyRange(JackCaptureLatency
, &range
);
93 int JackAlsaDriver::Attach()
96 jack_port_id_t port_index
;
97 unsigned long port_flags
= (unsigned long)CaptureDriverFlags
;
98 char name
[REAL_JACK_PORT_NAME_SIZE
];
99 char alias
[REAL_JACK_PORT_NAME_SIZE
];
101 assert(fCaptureChannels
< DRIVER_PORT_NUM
);
102 assert(fPlaybackChannels
< DRIVER_PORT_NUM
);
104 alsa_driver_t
* alsa_driver
= (alsa_driver_t
*)fDriver
;
106 if (alsa_driver
->has_hw_monitoring
)
107 port_flags
|= JackPortCanMonitor
;
109 // ALSA driver may have changed the values
110 JackAudioDriver::SetBufferSize(alsa_driver
->frames_per_cycle
);
111 JackAudioDriver::SetSampleRate(alsa_driver
->frame_rate
);
113 jack_log("JackAlsaDriver::Attach fBufferSize %ld fSampleRate %ld", fEngineControl
->fBufferSize
, fEngineControl
->fSampleRate
);
115 for (int i
= 0; i
< fCaptureChannels
; i
++) {
116 snprintf(alias
, sizeof(alias
), "%s:%s:out%d", fAliasName
, fCaptureDriverName
, i
+ 1);
117 snprintf(name
, sizeof(name
), "%s:capture_%d", fClientControl
.fName
, i
+ 1);
118 if (fEngine
->PortRegister(fClientControl
.fRefNum
, name
, JACK_DEFAULT_AUDIO_TYPE
, (JackPortFlags
)port_flags
, fEngineControl
->fBufferSize
, &port_index
) < 0) {
119 jack_error("driver: cannot register port for %s", name
);
122 port
= fGraphManager
->GetPort(port_index
);
123 port
->SetAlias(alias
);
124 fCapturePortList
[i
] = port_index
;
125 jack_log("JackAlsaDriver::Attach fCapturePortList[i] %ld ", port_index
);
128 port_flags
= (unsigned long)PlaybackDriverFlags
;
130 for (int i
= 0; i
< fPlaybackChannels
; i
++) {
131 snprintf(alias
, sizeof(alias
), "%s:%s:in%d", fAliasName
, fPlaybackDriverName
, i
+ 1);
132 snprintf(name
, sizeof(name
), "%s:playback_%d", fClientControl
.fName
, i
+ 1);
133 if (fEngine
->PortRegister(fClientControl
.fRefNum
, name
, JACK_DEFAULT_AUDIO_TYPE
, (JackPortFlags
)port_flags
, fEngineControl
->fBufferSize
, &port_index
) < 0) {
134 jack_error("driver: cannot register port for %s", name
);
137 port
= fGraphManager
->GetPort(port_index
);
138 port
->SetAlias(alias
);
139 fPlaybackPortList
[i
] = port_index
;
140 jack_log("JackAlsaDriver::Attach fPlaybackPortList[i] %ld ", port_index
);
143 if (fWithMonitorPorts
) {
144 jack_log("Create monitor port");
145 snprintf(name
, sizeof(name
), "%s:monitor_%d", fClientControl
.fName
, i
+ 1);
146 if (fEngine
->PortRegister(fClientControl
.fRefNum
, name
, JACK_DEFAULT_AUDIO_TYPE
, MonitorDriverFlags
, fEngineControl
->fBufferSize
, &port_index
) < 0) {
147 jack_error("ALSA: cannot register monitor port for %s", name
);
149 fMonitorPortList
[i
] = port_index
;
156 if (alsa_driver
->midi
) {
157 int err
= (alsa_driver
->midi
->attach
)(alsa_driver
->midi
);
159 jack_error ("ALSA: cannot attach MIDI: %d", err
);
165 int JackAlsaDriver::Detach()
167 alsa_driver_t
* alsa_driver
= (alsa_driver_t
*)fDriver
;
168 if (alsa_driver
->midi
)
169 (alsa_driver
->midi
->detach
)(alsa_driver
->midi
);
171 return JackAudioDriver::Detach();
174 extern "C" char* get_control_device_name(const char * device_name
)
179 /* the user wants a hw or plughw device, the ctl name
180 * should be hw:x where x is the card identification.
181 * We skip the subdevice suffix that starts with comma */
183 if (strncasecmp(device_name
, "plughw:", 7) == 0) {
184 /* skip the "plug" prefix" */
188 comma
= strchr(device_name
, ',');
190 ctl_name
= strdup(device_name
);
191 if (ctl_name
== NULL
) {
192 jack_error("strdup(\"%s\") failed.", device_name
);
195 ctl_name
= strndup(device_name
, comma
- device_name
);
196 if (ctl_name
== NULL
) {
197 jack_error("strndup(\"%s\", %u) failed.", device_name
, (unsigned int)(comma
- device_name
));
204 static int card_to_num(const char* device
)
208 snd_ctl_card_info_t
*card_info
;
209 snd_ctl_t
* ctl_handle
;
212 snd_ctl_card_info_alloca (&card_info
);
214 ctl_name
= get_control_device_name(device
);
215 if (ctl_name
== NULL
) {
216 jack_error("get_control_device_name() failed.");
220 if ((err
= snd_ctl_open (&ctl_handle
, ctl_name
, 0)) < 0) {
221 jack_error ("control open \"%s\" (%s)", ctl_name
,
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
));
232 i
= snd_ctl_card_info_get_card(card_info
);
235 snd_ctl_close(ctl_handle
);
244 int JackAlsaDriver::Open(jack_nframes_t nframes
,
245 jack_nframes_t user_nperiods
,
246 jack_nframes_t samplerate
,
251 DitherAlgorithm dither
,
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
)
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) {
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);
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
);
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
);
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
);
302 fDriver
= alsa_driver_new ((char*)"alsa_pcm", (char*)playback_driver_name
, (char*)capture_driver_name
,
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
;
326 JackAudioDriver::Close();
331 int JackAlsaDriver::Close()
333 // Generic audio driver close
334 int res
= JackAudioDriver::Close();
336 alsa_driver_delete((alsa_driver_t
*)fDriver
);
338 if (JackServerGlobals::on_device_release
!= NULL
)
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
);
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
);
357 int JackAlsaDriver::Start()
359 int res
= JackAudioDriver::Start();
361 res
= alsa_driver_start((alsa_driver_t
*)fDriver
);
363 JackAudioDriver::Stop();
369 int JackAlsaDriver::Stop()
371 int res
= alsa_driver_stop((alsa_driver_t
*)fDriver
);
372 if (JackAudioDriver::Stop() < 0) {
378 int JackAlsaDriver::Read()
380 /* Taken from alsa_driver_run_cycle */
382 jack_nframes_t nframes
;
387 nframes
= alsa_driver_wait((alsa_driver_t
*)fDriver
, -1, &wait_status
, &fDelayedUsecs
);
390 return -1; /* driver failed */
393 /* we detected an xrun and restarted: notify
394 * clients about the delay.
396 jack_log("ALSA XRun wait_status = %d", wait_status
);
397 NotifyXRun(fBeginDateUst
, fDelayedUsecs
);
398 goto retry
; /* recoverable error*/
401 if (nframes
!= fEngineControl
->fBufferSize
)
402 jack_log("JackAlsaDriver::Read warning fBufferSize = %ld nframes = %ld", fEngineControl
->fBufferSize
, nframes
);
404 // Has to be done before read
405 JackDriver::CycleIncTime();
407 return alsa_driver_read((alsa_driver_t
*)fDriver
, fEngineControl
->fBufferSize
);
410 int JackAlsaDriver::Write()
412 return alsa_driver_write((alsa_driver_t
*)fDriver
, fEngineControl
->fBufferSize
);
415 void JackAlsaDriver::ReadInputAux(jack_nframes_t orig_nframes
, snd_pcm_sframes_t contiguous
, snd_pcm_sframes_t nread
)
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
);
425 void JackAlsaDriver::MonitorInputAux()
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
);
435 void JackAlsaDriver::ClearOutputAux()
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
);
444 void JackAlsaDriver::SetTimetAux(jack_time_t time
)
446 fBeginDateUst
= time
;
449 void JackAlsaDriver::WriteOutputAux(jack_nframes_t orig_nframes
, snd_pcm_sframes_t contiguous
, snd_pcm_sframes_t nwritten
)
451 for (int chn
= 0; chn
< fPlaybackChannels
; chn
++) {
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
);
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
));
465 int JackAlsaDriver::is_realtime() const
467 return fEngineControl
->fRealTime
;
470 int JackAlsaDriver::create_thread(pthread_t
*thread
, int priority
, int realtime
, void *(*start_routine
)(void*), void *arg
)
472 return JackPosixThread::StartImp(thread
, priority
, realtime
, start_routine
, arg
);
475 jack_port_id_t
JackAlsaDriver::port_register(const char *port_name
, const char *port_type
, unsigned long flags
, unsigned long buffer_size
)
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;
482 int JackAlsaDriver::port_unregister(jack_port_id_t port_index
)
484 return fEngine
->PortUnRegister(fClientControl
.fRefNum
, port_index
);
487 void* JackAlsaDriver::port_get_buffer(int port
, jack_nframes_t nframes
)
489 return fGraphManager
->GetBuffer(port
, nframes
);
492 int JackAlsaDriver::port_set_alias(int port
, const char* name
)
494 return fGraphManager
->GetPort(port
)->SetAlias(name
);
497 jack_nframes_t
JackAlsaDriver::get_sample_rate() const
499 return fEngineControl
->fSampleRate
;
502 jack_nframes_t
JackAlsaDriver::frame_time() const
505 fEngineControl
->ReadFrameTime(&timer
);
506 return timer
.Time2Frames(GetMicroSeconds(), fEngineControl
->fBufferSize
);
509 jack_nframes_t
JackAlsaDriver::last_frame_time() const
512 fEngineControl
->ReadFrameTime(&timer
);
513 return timer
.CurFrame();
516 } // end of namespace
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
)
532 jack_driver_param_value_enum_t
* possible_value_ptr
;
534 //jack_info("%6s - %s", device_id, device_description);
536 if (*constraint_ptr_ptr
== NULL
)
538 *constraint_ptr_ptr
= (jack_driver_param_constraint_desc_t
*)calloc(1, sizeof(jack_driver_param_value_enum_t
));
542 if ((*constraint_ptr_ptr
)->constraint
.enumeration
.count
== *array_size_ptr
)
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
);
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
);
558 jack_driver_param_constraint_desc_t
*
562 snd_ctl_card_info_t
* info
;
563 snd_pcm_info_t
* pcminfo_capture
;
564 snd_pcm_info_t
* pcminfo_playback
;
566 char card_id
[JACK_DRIVER_PARAM_STRING_MAX
+ 1];
567 char device_id
[JACK_DRIVER_PARAM_STRING_MAX
+ 1];
568 char description
[64];
572 jack_driver_param_constraint_desc_t
* constraint_ptr
;
573 uint32_t array_size
= 0;
575 snd_ctl_card_info_alloca(&info
);
576 snd_pcm_info_alloca(&pcminfo_capture
);
577 snd_pcm_info_alloca(&pcminfo_playback
);
579 constraint_ptr
= NULL
;
581 while(snd_card_next(&card_no
) >= 0 && card_no
>= 0)
583 snprintf(card_id
, sizeof(card_id
), "hw:%d", card_no
);
585 if (snd_ctl_open(&handle
, card_id
, 0) >= 0 &&
586 snd_ctl_card_info(handle
, info
) >= 0)
588 snprintf(card_id
, sizeof(card_id
), "hw:%s", snd_ctl_card_info_get_id(info
));
589 fill_device(&constraint_ptr
, &array_size
, card_id
, snd_ctl_card_info_get_name(info
));
593 while (snd_ctl_pcm_next_device(handle
, &device_no
) >= 0 && device_no
!= -1)
595 snprintf(device_id
, sizeof(device_id
), "%s,%d", card_id
, device_no
);
597 snd_pcm_info_set_device(pcminfo_capture
, device_no
);
598 snd_pcm_info_set_subdevice(pcminfo_capture
, 0);
599 snd_pcm_info_set_stream(pcminfo_capture
, SND_PCM_STREAM_CAPTURE
);
600 has_capture
= snd_ctl_pcm_info(handle
, pcminfo_capture
) >= 0;
602 snd_pcm_info_set_device(pcminfo_playback
, device_no
);
603 snd_pcm_info_set_subdevice(pcminfo_playback
, 0);
604 snd_pcm_info_set_stream(pcminfo_playback
, SND_PCM_STREAM_PLAYBACK
);
605 has_playback
= snd_ctl_pcm_info(handle
, pcminfo_playback
) >= 0;
607 if (has_capture
&& has_playback
)
609 snprintf(description
, sizeof(description
),"%s (duplex)", snd_pcm_info_get_name(pcminfo_capture
));
611 else if (has_capture
)
613 snprintf(description
, sizeof(description
),"%s (capture)", snd_pcm_info_get_name(pcminfo_capture
));
615 else if (has_playback
)
617 snprintf(description
, sizeof(description
),"%s (playback)", snd_pcm_info_get_name(pcminfo_playback
));
624 fill_device(&constraint_ptr
, &array_size
, device_id
, description
);
627 snd_ctl_close(handle
);
631 return constraint_ptr
;
635 jack_driver_param_constraint_desc_t
*
636 get_midi_driver_constraint()
638 jack_driver_param_constraint_desc_t
* constraint_ptr
;
639 jack_driver_param_value_enum_t
* possible_value_ptr
;
641 //jack_info("%6s - %s", device_id, device_description);
643 constraint_ptr
= (jack_driver_param_constraint_desc_t
*)calloc(1, sizeof(jack_driver_param_value_enum_t
));
644 constraint_ptr
->flags
= JACK_CONSTRAINT_FLAG_STRICT
| JACK_CONSTRAINT_FLAG_FAKE_VALUE
;
646 constraint_ptr
->constraint
.enumeration
.possible_values_array
= (jack_driver_param_value_enum_t
*)malloc(3 * sizeof(jack_driver_param_value_enum_t
));
647 constraint_ptr
->constraint
.enumeration
.count
= 3;
649 possible_value_ptr
= constraint_ptr
->constraint
.enumeration
.possible_values_array
;
651 strcpy(possible_value_ptr
->value
.str
, "none");
652 strcpy(possible_value_ptr
->short_desc
, "no MIDI driver");
654 possible_value_ptr
++;
656 strcpy(possible_value_ptr
->value
.str
, "seq");
657 strcpy(possible_value_ptr
->short_desc
, "ALSA Sequencer driver");
659 possible_value_ptr
++;
661 strcpy(possible_value_ptr
->value
.str
, "raw");
662 strcpy(possible_value_ptr
->short_desc
, "ALSA RawMIDI driver");
664 return constraint_ptr
;
668 jack_driver_param_constraint_desc_t
*
669 get_dither_constraint()
671 jack_driver_param_constraint_desc_t
* constraint_ptr
;
672 jack_driver_param_value_enum_t
* possible_value_ptr
;
674 //jack_info("%6s - %s", device_id, device_description);
676 constraint_ptr
= (jack_driver_param_constraint_desc_t
*)calloc(1, sizeof(jack_driver_param_value_enum_t
));
677 constraint_ptr
->flags
= JACK_CONSTRAINT_FLAG_STRICT
| JACK_CONSTRAINT_FLAG_FAKE_VALUE
;
679 constraint_ptr
->constraint
.enumeration
.possible_values_array
= (jack_driver_param_value_enum_t
*)malloc(4 * sizeof(jack_driver_param_value_enum_t
));
680 constraint_ptr
->constraint
.enumeration
.count
= 4;
682 possible_value_ptr
= constraint_ptr
->constraint
.enumeration
.possible_values_array
;
684 possible_value_ptr
->value
.c
= 'n';
685 strcpy(possible_value_ptr
->short_desc
, "none");
687 possible_value_ptr
++;
689 possible_value_ptr
->value
.c
= 'r';
690 strcpy(possible_value_ptr
->short_desc
, "rectangular");
692 possible_value_ptr
++;
694 possible_value_ptr
->value
.c
= 's';
695 strcpy(possible_value_ptr
->short_desc
, "shaped");
697 possible_value_ptr
++;
699 possible_value_ptr
->value
.c
= 't';
700 strcpy(possible_value_ptr
->short_desc
, "triangular");
702 return constraint_ptr
;
706 dither_opt (char c
, DitherAlgorithm
* dither
)
715 *dither
= Rectangular
;
723 *dither
= Triangular
;
727 fprintf (stderr
, "ALSA driver: illegal dithering mode %c\n", c
);
733 SERVER_EXPORT
const jack_driver_desc_t
* driver_get_descriptor ()
735 jack_driver_desc_t
* desc
;
736 jack_driver_desc_filler_t filler
;
737 jack_driver_param_value_t value
;
739 desc
= jack_driver_descriptor_construct("alsa", JackDriverMaster
, "Linux ALSA API based audio backend", &filler
);
741 strcpy(value
.str
, "hw:0");
742 jack_driver_descriptor_add_parameter(desc
, &filler
, "device", 'd', JackDriverParamString
, &value
, enum_alsa_devices(), "ALSA device name", NULL
);
744 strcpy(value
.str
, "none");
745 jack_driver_descriptor_add_parameter(desc
, &filler
, "capture", 'C', JackDriverParamString
, &value
, NULL
, "Provide capture ports. Optionally set device", NULL
);
746 jack_driver_descriptor_add_parameter(desc
, &filler
, "playback", 'P', JackDriverParamString
, &value
, NULL
, "Provide playback ports. Optionally set device", NULL
);
749 jack_driver_descriptor_add_parameter(desc
, &filler
, "rate", 'r', JackDriverParamUInt
, &value
, NULL
, "Sample rate", NULL
);
752 jack_driver_descriptor_add_parameter(desc
, &filler
, "period", 'p', JackDriverParamUInt
, &value
, NULL
, "Frames per period", NULL
);
755 jack_driver_descriptor_add_parameter(desc
, &filler
, "nperiods", 'n', JackDriverParamUInt
, &value
, NULL
, "Number of periods of playback latency", NULL
);
758 jack_driver_descriptor_add_parameter(desc
, &filler
, "hwmon", 'H', JackDriverParamBool
, &value
, NULL
, "Hardware monitoring, if available", NULL
);
761 jack_driver_descriptor_add_parameter(desc
, &filler
, "hwmeter", 'M', JackDriverParamBool
, &value
, NULL
, "Hardware metering, if available", NULL
);
764 jack_driver_descriptor_add_parameter(desc
, &filler
, "duplex", 'D', JackDriverParamBool
, &value
, NULL
, "Provide both capture and playback ports", NULL
);
767 jack_driver_descriptor_add_parameter(desc
, &filler
, "softmode", 's', JackDriverParamBool
, &value
, NULL
, "Soft-mode, no xrun handling", NULL
);
770 jack_driver_descriptor_add_parameter(desc
, &filler
, "monitor", 'm', JackDriverParamBool
, &value
, NULL
, "Provide monitor ports for the output", NULL
);
773 jack_driver_descriptor_add_parameter(
780 get_dither_constraint(),
789 jack_driver_descriptor_add_parameter(desc
, &filler
, "inchannels", 'i', JackDriverParamUInt
, &value
, NULL
, "Number of capture channels (defaults to hardware max)", NULL
);
790 jack_driver_descriptor_add_parameter(desc
, &filler
, "outchannels", 'o', JackDriverParamUInt
, &value
, NULL
, "Number of playback channels (defaults to hardware max)", NULL
);
793 jack_driver_descriptor_add_parameter(desc
, &filler
, "shorts", 'S', JackDriverParamBool
, &value
, NULL
, "Try 16-bit samples before 32-bit", NULL
);
796 jack_driver_descriptor_add_parameter(desc
, &filler
, "input-latency", 'I', JackDriverParamUInt
, &value
, NULL
, "Extra input latency (frames)", NULL
);
797 jack_driver_descriptor_add_parameter(desc
, &filler
, "output-latency", 'O', JackDriverParamUInt
, &value
, NULL
, "Extra output latency (frames)", NULL
);
799 strcpy(value
.str
, "none");
800 jack_driver_descriptor_add_parameter(
805 JackDriverParamString
,
807 get_midi_driver_constraint(),
809 "ALSA MIDI driver:\n"
810 " none - no MIDI driver\n"
811 " seq - ALSA Sequencer driver\n"
812 " raw - ALSA RawMIDI driver\n");
817 static Jack::JackAlsaDriver
* g_alsa_driver
;
819 SERVER_EXPORT
Jack::JackDriverClientInterface
* driver_initialize(Jack::JackLockedEngine
* engine
, Jack::JackSynchro
* table
, const JSList
* params
)
821 jack_nframes_t srate
= 48000;
822 jack_nframes_t frames_per_interrupt
= 1024;
823 unsigned long user_nperiods
= 2;
824 const char *playback_pcm_name
= "hw:0";
825 const char *capture_pcm_name
= "hw:0";
826 int hw_monitoring
= FALSE
;
827 int hw_metering
= FALSE
;
829 int playback
= FALSE
;
830 int soft_mode
= FALSE
;
832 DitherAlgorithm dither
= None
;
833 int user_capture_nchnls
= 0;
834 int user_playback_nchnls
= 0;
835 int shorts_first
= FALSE
;
836 jack_nframes_t systemic_input_latency
= 0;
837 jack_nframes_t systemic_output_latency
= 0;
839 const jack_driver_param_t
* param
;
840 const char *midi_driver
= "none";
842 for (node
= params
; node
; node
= jack_slist_next (node
)) {
843 param
= (const jack_driver_param_t
*) node
->data
;
845 switch (param
->character
) {
849 if (strcmp (param
->value
.str
, "none") != 0) {
850 capture_pcm_name
= strdup (param
->value
.str
);
851 jack_log("capture device %s", capture_pcm_name
);
857 if (strcmp (param
->value
.str
, "none") != 0) {
858 playback_pcm_name
= strdup (param
->value
.str
);
859 jack_log("playback device %s", playback_pcm_name
);
869 if (strcmp (param
->value
.str
, "none") != 0) {
870 playback_pcm_name
= strdup (param
->value
.str
);
871 capture_pcm_name
= strdup (param
->value
.str
);
872 jack_log("playback device %s", playback_pcm_name
);
873 jack_log("capture device %s", capture_pcm_name
);
878 hw_monitoring
= param
->value
.i
;
882 monitor
= param
->value
.i
;
886 hw_metering
= param
->value
.i
;
890 srate
= param
->value
.ui
;
891 jack_log("apparent rate = %d", srate
);
895 frames_per_interrupt
= param
->value
.ui
;
896 jack_log("frames per period = %d", frames_per_interrupt
);
900 user_nperiods
= param
->value
.ui
;
901 if (user_nperiods
< 2) { /* enforce minimum value */
907 soft_mode
= param
->value
.i
;
911 if (dither_opt (param
->value
.c
, &dither
)) {
917 user_capture_nchnls
= param
->value
.ui
;
921 user_playback_nchnls
= param
->value
.ui
;
925 shorts_first
= param
->value
.i
;
929 systemic_input_latency
= param
->value
.ui
;
933 systemic_output_latency
= param
->value
.ui
;
937 midi_driver
= strdup(param
->value
.str
);
942 /* duplex is the default */
943 if (!capture
&& !playback
) {
948 g_alsa_driver
= new Jack::JackAlsaDriver("system", "alsa_pcm", engine
, table
);
949 Jack::JackDriverClientInterface
* threaded_driver
= new Jack::JackThreadedDriver(g_alsa_driver
);
950 // Special open for ALSA driver...
951 if (g_alsa_driver
->Open(frames_per_interrupt
, user_nperiods
, srate
, hw_monitoring
, hw_metering
, capture
, playback
, dither
, soft_mode
, monitor
,
952 user_capture_nchnls
, user_playback_nchnls
, shorts_first
, capture_pcm_name
, playback_pcm_name
,
953 systemic_input_latency
, systemic_output_latency
, midi_driver
) == 0) {
954 return threaded_driver
;
956 delete threaded_driver
; // Delete the decorated driver
961 // Code to be used in alsa_driver.c
963 void ReadInput(jack_nframes_t orig_nframes
, snd_pcm_sframes_t contiguous
, snd_pcm_sframes_t nread
)
965 g_alsa_driver
->ReadInputAux(orig_nframes
, contiguous
, nread
);
969 g_alsa_driver
->MonitorInputAux();
973 g_alsa_driver
->ClearOutputAux();
975 void WriteOutput(jack_nframes_t orig_nframes
, snd_pcm_sframes_t contiguous
, snd_pcm_sframes_t nwritten
)
977 g_alsa_driver
->WriteOutputAux(orig_nframes
, contiguous
, nwritten
);
979 void SetTime(jack_time_t time
)
981 g_alsa_driver
->SetTimetAux(time
);
987 if ((res
= g_alsa_driver
->Stop()) == 0) {
988 res
= g_alsa_driver
->Start();