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" 43 #include "JackAndroidThread.h" 45 #include "JackPosixThread.h" 47 #include "JackCompilerDeps.h" 48 #include "JackServerGlobals.h" 49 #include "port_names.h" 53 {
"none",
"no MIDI driver" },
54 {
"seq",
"ALSA Sequencer driver" },
55 {
"raw",
"ALSA RawMIDI driver" },
62 {
'r',
"rectangular" },
64 {
't',
"triangular" },
71 int JackAlsaDriver::SetBufferSize(jack_nframes_t buffer_size)
73 jack_log(
"JackAlsaDriver::SetBufferSize %ld", buffer_size);
74 int res = alsa_driver_reset_parameters((
alsa_driver_t *)fDriver, buffer_size,
79 JackAudioDriver::SetBufferSize(buffer_size);
84 alsa_driver_reset_parameters((
alsa_driver_t *)fDriver, fEngineControl->fBufferSize,
92 void JackAlsaDriver::UpdateLatencies()
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);
102 for (
int i = 0; i < fPlaybackChannels; i++) {
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);
108 if (fWithMonitorPorts) {
109 range.
min = range.
max = alsa_driver->frames_per_cycle;
110 fGraphManager->GetPort(fMonitorPortList[i])->SetLatencyRange(JackCaptureLatency, &range);
115 int JackAlsaDriver::Attach()
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];
125 assert(fCaptureChannels < DRIVER_PORT_NUM);
126 assert(fPlaybackChannels < DRIVER_PORT_NUM);
130 if (alsa_driver->has_hw_monitoring)
131 port_flags |= JackPortCanMonitor;
134 JackAudioDriver::SetBufferSize(alsa_driver->frames_per_cycle);
135 JackAudioDriver::SetSampleRate(alsa_driver->frame_rate);
137 jack_log(
"JackAlsaDriver::Attach fBufferSize %ld fSampleRate %ld", fEngineControl->fBufferSize, fEngineControl->fSampleRate);
139 portnames = port_names_get_portnames(alsa_driver);
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);
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);
156 port_flags = (
unsigned long)PlaybackDriverFlags;
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);
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);
173 if (fWithMonitorPorts) {
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);
179 fMonitorPortList[i] = port_index;
188 if (alsa_driver->midi) {
189 int err = (alsa_driver->midi->attach)(alsa_driver->midi);
191 jack_error (
"ALSA: cannot attach MIDI: %d", err);
197 int JackAlsaDriver::Detach()
200 if (alsa_driver->midi)
201 (alsa_driver->midi->detach)(alsa_driver->midi);
203 return JackAudioDriver::Detach();
206 extern "C" char* get_control_device_name(
const char * device_name)
215 if (strncasecmp(device_name,
"plughw:", 7) == 0) {
220 comma = strchr(device_name,
',');
222 ctl_name = strdup(device_name);
223 if (ctl_name == NULL) {
224 jack_error(
"strdup(\"%s\") failed.", device_name);
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));
236 static int card_to_num(
const char* device)
240 snd_ctl_card_info_t *card_info;
241 snd_ctl_t* ctl_handle;
244 snd_ctl_card_info_alloca (&card_info);
246 ctl_name = get_control_device_name(device);
247 if (ctl_name == NULL) {
248 jack_error(
"get_control_device_name() failed.");
252 if ((err = snd_ctl_open (&ctl_handle, ctl_name, 0)) < 0) {
253 jack_error (
"control open \"%s\" (%s)", ctl_name,
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));
264 i = snd_ctl_card_info_get_card(card_info);
267 snd_ctl_close(ctl_handle);
276 int JackAlsaDriver::Open(jack_nframes_t nframes,
277 jack_nframes_t user_nperiods,
278 jack_nframes_t samplerate,
283 DitherAlgorithm dither,
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)
296 if (JackAudioDriver::Open(nframes, samplerate, capturing, playing,
297 inchannels, outchannels, monitor, capture_driver_name, playback_driver_name,
298 capture_latency, playback_latency) != 0) {
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);
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);
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);
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);
336 fDriver = alsa_driver_new ((
char*)
"alsa_pcm", (
char*)playback_driver_name, (
char*)capture_driver_name,
356 fCaptureChannels = ((
alsa_driver_t *)fDriver)->capture_nchannels;
357 fPlaybackChannels = ((
alsa_driver_t *)fDriver)->playback_nchannels;
360 JackAudioDriver::Close();
365 int JackAlsaDriver::Close()
368 int res = JackAudioDriver::Close();
372 if (JackServerGlobals::on_device_release != NULL)
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);
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);
391 int JackAlsaDriver::Start()
393 int res = JackAudioDriver::Start();
397 JackAudioDriver::Stop();
403 int JackAlsaDriver::Stop()
406 if (JackAudioDriver::Stop() < 0) {
412 int JackAlsaDriver::Read()
416 jack_nframes_t nframes;
421 nframes = alsa_driver_wait((
alsa_driver_t *)fDriver, -1, &wait_status, &fDelayedUsecs);
430 jack_log(
"ALSA XRun wait_status = %d", wait_status);
431 NotifyXRun(fBeginDateUst, fDelayedUsecs);
435 if (nframes != fEngineControl->fBufferSize)
436 jack_log(
"JackAlsaDriver::Read warning fBufferSize = %ld nframes = %ld", fEngineControl->fBufferSize, nframes);
439 JackDriver::CycleIncTime();
441 return alsa_driver_read((
alsa_driver_t *)fDriver, fEngineControl->fBufferSize);
444 int JackAlsaDriver::Write()
446 return alsa_driver_write((
alsa_driver_t *)fDriver, fEngineControl->fBufferSize);
449 void JackAlsaDriver::ReadInputAux(jack_nframes_t orig_nframes, snd_pcm_sframes_t contiguous, snd_pcm_sframes_t nread)
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);
459 void JackAlsaDriver::MonitorInputAux()
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);
469 void JackAlsaDriver::ClearOutputAux()
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);
478 void JackAlsaDriver::SetTimetAux(jack_time_t time)
480 fBeginDateUst = time;
483 void JackAlsaDriver::WriteOutputAux(jack_nframes_t orig_nframes, snd_pcm_sframes_t contiguous, snd_pcm_sframes_t nwritten)
485 for (
int chn = 0; chn < fPlaybackChannels; chn++) {
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);
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));
499 int JackAlsaDriver::is_realtime()
const 501 return fEngineControl->fRealTime;
504 int JackAlsaDriver::create_thread(pthread_t *thread,
int priority,
int realtime,
void *(*start_routine)(
void*),
void *arg)
507 return JackAndroidThread::StartImp(thread, priority, realtime, start_routine, arg);
509 return JackPosixThread::StartImp(thread, priority, realtime, start_routine, arg);
513 jack_port_id_t JackAlsaDriver::port_register(
const char *port_name,
const char *port_type,
unsigned long flags,
unsigned long buffer_size)
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;
520 int JackAlsaDriver::port_unregister(jack_port_id_t port_index)
522 return fEngine->PortUnRegister(fClientControl.fRefNum, port_index);
525 void* JackAlsaDriver::port_get_buffer(
int port, jack_nframes_t nframes)
527 return fGraphManager->GetBuffer(port, nframes);
530 int JackAlsaDriver::port_set_alias(
int port,
const char* name)
532 return fGraphManager->GetPort(port)->SetAlias(name);
535 jack_nframes_t JackAlsaDriver::get_sample_rate()
const 537 return fEngineControl->fSampleRate;
540 jack_nframes_t JackAlsaDriver::frame_time()
const 543 fEngineControl->ReadFrameTime(&timer);
544 return timer.Time2Frames(GetMicroSeconds(), fEngineControl->fBufferSize);
547 jack_nframes_t JackAlsaDriver::last_frame_time()
const 550 fEngineControl->ReadFrameTime(&timer);
551 return timer.CurFrame();
567 snd_ctl_card_info_t * info;
568 snd_pcm_info_t * pcminfo_capture;
569 snd_pcm_info_t * pcminfo_playback;
573 char description[64];
578 uint32_t array_size = 0;
580 snd_ctl_card_info_alloca(&info);
581 snd_pcm_info_alloca(&pcminfo_capture);
582 snd_pcm_info_alloca(&pcminfo_playback);
584 constraint_ptr = NULL;
586 while(snd_card_next(&card_no) >= 0 && card_no >= 0)
588 snprintf(card_id.str,
sizeof(card_id.str),
"hw:%d", card_no);
590 if (snd_ctl_open(&handle, card_id.str, 0) >= 0 &&
591 snd_ctl_card_info(handle, info) >= 0)
593 snprintf(card_id.str,
sizeof(card_id.str),
"hw:%s", snd_ctl_card_info_get_id(info));
594 if (!jack_constraint_add_enum(
598 snd_ctl_card_info_get_name(info)))
603 while (snd_ctl_pcm_next_device(handle, &device_no) >= 0 && device_no != -1)
605 snprintf(device_id.str,
sizeof(device_id.str),
"%s,%d", card_id.str, device_no);
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;
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;
617 if (has_capture && has_playback)
619 snprintf(description,
sizeof(description),
"%s (duplex)", snd_pcm_info_get_name(pcminfo_capture));
621 else if (has_capture)
623 snprintf(description,
sizeof(description),
"%s (capture)", snd_pcm_info_get_name(pcminfo_capture));
625 else if (has_playback)
627 snprintf(description,
sizeof(description),
"%s (playback)", snd_pcm_info_get_name(pcminfo_playback));
634 if (!jack_constraint_add_enum(
642 snd_ctl_close(handle);
646 return constraint_ptr;
648 jack_constraint_free(constraint_ptr);
653 dither_opt (
char c, DitherAlgorithm* dither)
662 *dither = Rectangular;
670 *dither = Triangular;
674 fprintf (stderr,
"ALSA driver: illegal dithering mode %c\n", c);
686 desc = jack_driver_descriptor_construct(
"alsa", JackDriverMaster,
"Linux ALSA API based audio backend", &filler);
688 strcpy(value.str,
"hw:0");
690 jack_driver_descriptor_add_parameter(desc, &filler,
"device",
'd', JackDriverParamString, &value, NULL,
"ALSA device name", NULL);
692 jack_driver_descriptor_add_parameter(desc, &filler,
"device",
'd', JackDriverParamString, &value, enum_alsa_devices(),
"ALSA device name", NULL);
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);
700 jack_driver_descriptor_add_parameter(desc, &filler,
"rate",
'r', JackDriverParamUInt, &value, NULL,
"Sample rate", NULL);
703 jack_driver_descriptor_add_parameter(desc, &filler,
"period",
'p', JackDriverParamUInt, &value, NULL,
"Frames per period", NULL);
706 jack_driver_descriptor_add_parameter(desc, &filler,
"nperiods",
'n', JackDriverParamUInt, &value, NULL,
"Number of periods of playback latency", NULL);
709 jack_driver_descriptor_add_parameter(desc, &filler,
"hwmon",
'H', JackDriverParamBool, &value, NULL,
"Hardware monitoring, if available", NULL);
712 jack_driver_descriptor_add_parameter(desc, &filler,
"hwmeter",
'M', JackDriverParamBool, &value, NULL,
"Hardware metering, if available", NULL);
715 jack_driver_descriptor_add_parameter(desc, &filler,
"duplex",
'D', JackDriverParamBool, &value, NULL,
"Provide both capture and playback ports", NULL);
718 jack_driver_descriptor_add_parameter(desc, &filler,
"softmode",
's', JackDriverParamBool, &value, NULL,
"Soft-mode, no xrun handling", NULL);
721 jack_driver_descriptor_add_parameter(desc, &filler,
"monitor",
'm', JackDriverParamBool, &value, NULL,
"Provide monitor ports for the output", NULL);
724 jack_driver_descriptor_add_parameter(
731 jack_constraint_compose_enum_char(
732 JACK_CONSTRAINT_FLAG_STRICT | JACK_CONSTRAINT_FLAG_FAKE_VALUE,
733 dither_constraint_descr_array),
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);
742 jack_driver_descriptor_add_parameter(desc, &filler,
"shorts",
'S', JackDriverParamBool, &value, NULL,
"Try 16-bit samples before 32-bit", NULL);
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);
748 strcpy(value.str,
"none");
749 jack_driver_descriptor_add_parameter(
754 JackDriverParamString,
756 jack_constraint_compose_enum_str(
757 JACK_CONSTRAINT_FLAG_STRICT | JACK_CONSTRAINT_FLAG_FAKE_VALUE,
758 midi_constraint_descr_array),
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;
777 int playback = FALSE;
778 int soft_mode = 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;
788 const char *midi_driver =
"none";
790 for (node = params; node; node = jack_slist_next (node)) {
793 switch (param->character) {
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);
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);
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);
826 hw_monitoring = param->value.i;
830 monitor = param->value.i;
834 hw_metering = param->value.i;
838 srate = param->value.ui;
839 jack_log(
"apparent rate = %d", srate);
843 frames_per_interrupt = param->value.ui;
844 jack_log(
"frames per period = %d", frames_per_interrupt);
848 user_nperiods = param->value.ui;
849 if (user_nperiods < 2) {
855 soft_mode = param->value.i;
859 if (dither_opt (param->value.c, &dither)) {
865 user_capture_nchnls = param->value.ui;
869 user_playback_nchnls = param->value.ui;
873 shorts_first = param->value.i;
877 systemic_input_latency = param->value.ui;
881 systemic_output_latency = param->value.ui;
885 midi_driver = strdup(param->value.str);
891 if (!capture && !playback) {
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;
904 delete threaded_driver;
911 void ReadInput(jack_nframes_t orig_nframes, snd_pcm_sframes_t contiguous, snd_pcm_sframes_t nread)
913 g_alsa_driver->ReadInputAux(orig_nframes, contiguous, nread);
917 g_alsa_driver->MonitorInputAux();
921 g_alsa_driver->ClearOutputAux();
923 void WriteOutput(jack_nframes_t orig_nframes, snd_pcm_sframes_t contiguous, snd_pcm_sframes_t nwritten)
925 g_alsa_driver->WriteOutputAux(orig_nframes, contiguous, nwritten);
927 void SetTime(jack_time_t time)
929 g_alsa_driver->SetTimetAux(time);
935 if ((res = g_alsa_driver->Stop()) == 0) {
936 res = g_alsa_driver->Start();
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.
SERVER_EXPORT void jack_error(const char *fmt,...)
The base interface for drivers clients.
SERVER_EXPORT void jack_log(const char *fmt,...)