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"    52     { 
"none", 
"no MIDI driver" },
    53     { 
"seq", 
"ALSA Sequencer driver" },
    54     { 
"raw", 
"ALSA RawMIDI driver" },
    61     { 
'r', 
"rectangular" },
    63     { 
't', 
"triangular" },
    70 int JackAlsaDriver::SetBufferSize(jack_nframes_t buffer_size)
    72     jack_log(
"JackAlsaDriver::SetBufferSize %ld", buffer_size);
    73     int res = alsa_driver_reset_parameters((
alsa_driver_t *)fDriver, buffer_size,
    78         JackAudioDriver::SetBufferSize(buffer_size);  
    83         alsa_driver_reset_parameters((
alsa_driver_t *)fDriver, fEngineControl->fBufferSize,
    91 void JackAlsaDriver::UpdateLatencies()
    96     for (
int i = 0; i < fCaptureChannels; i++) {
    97         range.
min = range.
max = alsa_driver->frames_per_cycle + alsa_driver->capture_frame_latency;
    98         fGraphManager->GetPort(fCapturePortList[i])->SetLatencyRange(JackCaptureLatency, &range);
   101     for (
int i = 0; i < fPlaybackChannels; i++) {
   103         range.
min = range.
max = (alsa_driver->frames_per_cycle * (alsa_driver->user_nperiods - 1)) +
   104                          ((fEngineControl->fSyncMode) ? 0 : fEngineControl->fBufferSize) + alsa_driver->playback_frame_latency;
   105         fGraphManager->GetPort(fPlaybackPortList[i])->SetLatencyRange(JackPlaybackLatency, &range);
   107         if (fWithMonitorPorts) {
   108             range.
min = range.
max = alsa_driver->frames_per_cycle;
   109             fGraphManager->GetPort(fMonitorPortList[i])->SetLatencyRange(JackCaptureLatency, &range);
   114 int JackAlsaDriver::Attach()
   117     jack_port_id_t port_index;
   118     unsigned long port_flags = (
unsigned long)CaptureDriverFlags;
   119     char name[REAL_JACK_PORT_NAME_SIZE+1];
   120     char alias[REAL_JACK_PORT_NAME_SIZE+1];
   122     assert(fCaptureChannels < DRIVER_PORT_NUM);
   123     assert(fPlaybackChannels < DRIVER_PORT_NUM);
   127     if (alsa_driver->has_hw_monitoring)
   128         port_flags |= JackPortCanMonitor;
   131     JackAudioDriver::SetBufferSize(alsa_driver->frames_per_cycle);
   132     JackAudioDriver::SetSampleRate(alsa_driver->frame_rate);
   134     jack_log(
"JackAlsaDriver::Attach fBufferSize %ld fSampleRate %ld", fEngineControl->fBufferSize, fEngineControl->fSampleRate);
   136     for (
int i = 0; i < fCaptureChannels; i++) {
   137         snprintf(alias, 
sizeof(alias), 
"%s:%s:out%d", fAliasName, fCaptureDriverName, i + 1);
   138         snprintf(name, 
sizeof(name), 
"%s:capture_%d", fClientControl.fName, i + 1);
   139         if (fEngine->PortRegister(fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE, (JackPortFlags)port_flags, fEngineControl->fBufferSize, &port_index) < 0) {
   140             jack_error(
"driver: cannot register port for %s", name);
   143         port = fGraphManager->GetPort(port_index);
   144         port->SetAlias(alias);
   145         fCapturePortList[i] = port_index;
   146         jack_log(
"JackAlsaDriver::Attach fCapturePortList[i] %ld ", port_index);
   149     port_flags = (
unsigned long)PlaybackDriverFlags;
   151     for (
int i = 0; i < fPlaybackChannels; i++) {
   152         snprintf(alias, 
sizeof(alias), 
"%s:%s:in%d", fAliasName, fPlaybackDriverName, i + 1);
   153         snprintf(name, 
sizeof(name), 
"%s:playback_%d", fClientControl.fName, i + 1);
   154         if (fEngine->PortRegister(fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE, (JackPortFlags)port_flags, fEngineControl->fBufferSize, &port_index) < 0) {
   155             jack_error(
"driver: cannot register port for %s", name);
   158         port = fGraphManager->GetPort(port_index);
   159         port->SetAlias(alias);
   160         fPlaybackPortList[i] = port_index;
   161         jack_log(
"JackAlsaDriver::Attach fPlaybackPortList[i] %ld ", port_index);
   164         if (fWithMonitorPorts) {
   166             snprintf(name, 
sizeof(name), 
"%s:monitor_%d", fClientControl.fName, i + 1);
   167             if (fEngine->PortRegister(fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE, MonitorDriverFlags, fEngineControl->fBufferSize, &port_index) < 0) {
   168                 jack_error(
"ALSA: cannot register monitor port for %s", name);
   170                 fMonitorPortList[i] = port_index;
   177     if (alsa_driver->midi) {
   178         int err = (alsa_driver->midi->attach)(alsa_driver->midi);
   180             jack_error (
"ALSA: cannot attach MIDI: %d", err);
   186 int JackAlsaDriver::Detach()
   189     if (alsa_driver->midi)
   190         (alsa_driver->midi->detach)(alsa_driver->midi);
   192     return JackAudioDriver::Detach();
   195 extern "C" char* get_control_device_name(
const char * device_name)
   204     if (strncasecmp(device_name, 
"plughw:", 7) == 0) {
   209     comma = strchr(device_name, 
',');
   211         ctl_name = strdup(device_name);
   212         if (ctl_name == NULL) {
   213             jack_error(
"strdup(\"%s\") failed.", device_name);
   216         ctl_name = strndup(device_name, comma - device_name);
   217         if (ctl_name == NULL) {
   218             jack_error(
"strndup(\"%s\", %u) failed.", device_name, (
unsigned int)(comma - device_name));
   225 static int card_to_num(
const char* device)
   229     snd_ctl_card_info_t *card_info;
   230     snd_ctl_t* ctl_handle;
   233     snd_ctl_card_info_alloca (&card_info);
   235     ctl_name = get_control_device_name(device);
   236     if (ctl_name == NULL) {
   237         jack_error(
"get_control_device_name() failed.");
   241     if ((err = snd_ctl_open (&ctl_handle, ctl_name, 0)) < 0) {
   242         jack_error (
"control open \"%s\" (%s)", ctl_name,
   247     if ((err = snd_ctl_card_info(ctl_handle, card_info)) < 0) {
   248         jack_error (
"control hardware info \"%s\" (%s)",
   249                     device, snd_strerror (err));
   253     i = snd_ctl_card_info_get_card(card_info);
   256     snd_ctl_close(ctl_handle);
   265 int JackAlsaDriver::Open(jack_nframes_t nframes,
   266                          jack_nframes_t user_nperiods,
   267                          jack_nframes_t samplerate,
   272                          DitherAlgorithm dither,
   278                          const char* capture_driver_name,
   279                          const char* playback_driver_name,
   280                          jack_nframes_t capture_latency,
   281                          jack_nframes_t playback_latency,
   282                          const char* midi_driver_name)
   285     if (JackAudioDriver::Open(nframes, samplerate, capturing, playing,
   286                               inchannels, outchannels, monitor, capture_driver_name, playback_driver_name,
   287                               capture_latency, playback_latency) != 0) {
   293     if (strcmp(midi_driver_name, 
"seq") == 0)
   294         midi = alsa_seqmidi_new((jack_client_t*)
this, 0);
   295     else if (strcmp(midi_driver_name, 
"raw") == 0)
   296         midi = alsa_rawmidi_new((jack_client_t*)
this);
   299     if (JackServerGlobals::on_device_acquire != NULL) {
   300         int capture_card = card_to_num(capture_driver_name);
   301         int playback_card = card_to_num(playback_driver_name);
   304         if (capture_card >= 0) {
   305             snprintf(audio_name, 
sizeof(audio_name), 
"Audio%d", capture_card);
   306             if (!JackServerGlobals::on_device_acquire(audio_name)) {
   307                 jack_error(
"Audio device %s cannot be acquired...", capture_driver_name);
   312         if (playback_card >= 0 && playback_card != capture_card) {
   313             snprintf(audio_name, 
sizeof(audio_name), 
"Audio%d", playback_card);
   314             if (!JackServerGlobals::on_device_acquire(audio_name)) {
   315                 jack_error(
"Audio device %s cannot be acquired...", playback_driver_name);
   316                 if (capture_card >= 0) {
   317                     snprintf(audio_name, 
sizeof(audio_name), 
"Audio%d", capture_card);
   318                     JackServerGlobals::on_device_release(audio_name);
   325     fDriver = alsa_driver_new ((
char*)
"alsa_pcm", (
char*)playback_driver_name, (
char*)capture_driver_name,
   345         fCaptureChannels = ((
alsa_driver_t *)fDriver)->capture_nchannels;
   346         fPlaybackChannels = ((
alsa_driver_t *)fDriver)->playback_nchannels;
   354 int JackAlsaDriver::Close()
   357     int res = JackAudioDriver::Close();
   363     if (JackServerGlobals::on_device_release != NULL)
   366         int capture_card = card_to_num(fCaptureDriverName);
   367         if (capture_card >= 0) {
   368             snprintf(audio_name, 
sizeof(audio_name), 
"Audio%d", capture_card);
   369             JackServerGlobals::on_device_release(audio_name);
   372         int playback_card = card_to_num(fPlaybackDriverName);
   373         if (playback_card >= 0 && playback_card != capture_card) {
   374             snprintf(audio_name, 
sizeof(audio_name), 
"Audio%d", playback_card);
   375             JackServerGlobals::on_device_release(audio_name);
   382 int JackAlsaDriver::Start()
   384     int res = JackAudioDriver::Start();
   388             JackAudioDriver::Stop();
   394 int JackAlsaDriver::Stop()
   397     if (JackAudioDriver::Stop() < 0) {
   403 int JackAlsaDriver::Read()
   407     jack_nframes_t nframes;
   412     nframes = alsa_driver_wait((
alsa_driver_t *)fDriver, -1, &wait_status, &fDelayedUsecs);
   421         jack_log(
"ALSA XRun wait_status = %d", wait_status);
   422         NotifyXRun(fBeginDateUst, fDelayedUsecs);
   426     if (nframes != fEngineControl->fBufferSize)
   427         jack_log(
"JackAlsaDriver::Read warning fBufferSize = %ld nframes = %ld", fEngineControl->fBufferSize, nframes);
   430     JackDriver::CycleIncTime();
   432     return alsa_driver_read((
alsa_driver_t *)fDriver, fEngineControl->fBufferSize);
   435 int JackAlsaDriver::Write()
   437     return alsa_driver_write((
alsa_driver_t *)fDriver, fEngineControl->fBufferSize);
   440 void JackAlsaDriver::ReadInputAux(jack_nframes_t orig_nframes, snd_pcm_sframes_t contiguous, snd_pcm_sframes_t nread)
   442     for (
int chn = 0; chn < fCaptureChannels; chn++) {
   443         if (fGraphManager->GetConnectionsNum(fCapturePortList[chn]) > 0) {
   444             jack_default_audio_sample_t* buf = (jack_default_audio_sample_t*)fGraphManager->GetBuffer(fCapturePortList[chn], orig_nframes);
   445             alsa_driver_read_from_channel((
alsa_driver_t *)fDriver, chn, buf + nread, contiguous);
   450 void JackAlsaDriver::MonitorInputAux()
   452     for (
int chn = 0; chn < fCaptureChannels; chn++) {
   453         JackPort* port = fGraphManager->GetPort(fCapturePortList[chn]);
   454         if (port->MonitoringInput()) {
   455             ((
alsa_driver_t *)fDriver)->input_monitor_mask |= (1 << chn);
   460 void JackAlsaDriver::ClearOutputAux()
   462     for (
int chn = 0; chn < fPlaybackChannels; chn++) {
   463         jack_default_audio_sample_t* buf =
   464             (jack_default_audio_sample_t*)fGraphManager->GetBuffer(fPlaybackPortList[chn], fEngineControl->fBufferSize);
   465         memset(buf, 0, 
sizeof (jack_default_audio_sample_t) * fEngineControl->fBufferSize);
   469 void JackAlsaDriver::SetTimetAux(jack_time_t time)
   471     fBeginDateUst = time;
   474 void JackAlsaDriver::WriteOutputAux(jack_nframes_t orig_nframes, snd_pcm_sframes_t contiguous, snd_pcm_sframes_t nwritten)
   476     for (
int chn = 0; chn < fPlaybackChannels; chn++) {
   478         if (fGraphManager->GetConnectionsNum(fPlaybackPortList[chn]) > 0) {
   479             jack_default_audio_sample_t* buf = (jack_default_audio_sample_t*)fGraphManager->GetBuffer(fPlaybackPortList[chn], orig_nframes);
   480             alsa_driver_write_to_channel(((
alsa_driver_t *)fDriver), chn, buf + nwritten, contiguous);
   482             if (fWithMonitorPorts && fGraphManager->GetConnectionsNum(fMonitorPortList[chn]) > 0) {
   483                 jack_default_audio_sample_t* monbuf = (jack_default_audio_sample_t*)fGraphManager->GetBuffer(fMonitorPortList[chn], orig_nframes);
   484                 memcpy(monbuf + nwritten, buf + nwritten, contiguous * 
sizeof(jack_default_audio_sample_t));
   490 int JackAlsaDriver::is_realtime()
 const   492     return fEngineControl->fRealTime;
   495 int JackAlsaDriver::create_thread(pthread_t *thread, 
int priority, 
int realtime, 
void *(*start_routine)(
void*), 
void *arg)
   498     return JackAndroidThread::StartImp(thread, priority, realtime, start_routine, arg);
   500     return JackPosixThread::StartImp(thread, priority, realtime, start_routine, arg);
   504 jack_port_id_t JackAlsaDriver::port_register(
const char *port_name, 
const char *port_type, 
unsigned long flags, 
unsigned long buffer_size)
   506     jack_port_id_t port_index;
   507     int res = fEngine->PortRegister(fClientControl.fRefNum, port_name, port_type, flags, buffer_size, &port_index);
   508     return (res == 0) ? port_index : 0;
   511 int JackAlsaDriver::port_unregister(jack_port_id_t port_index)
   513     return fEngine->PortUnRegister(fClientControl.fRefNum, port_index);
   516 void* JackAlsaDriver::port_get_buffer(
int port, jack_nframes_t nframes)
   518     return fGraphManager->GetBuffer(port, nframes);
   521 int  JackAlsaDriver::port_set_alias(
int port, 
const char* name)
   523     return fGraphManager->GetPort(port)->SetAlias(name);
   526 jack_nframes_t JackAlsaDriver::get_sample_rate()
 const   528     return fEngineControl->fSampleRate;
   531 jack_nframes_t JackAlsaDriver::frame_time()
 const   534     fEngineControl->ReadFrameTime(&timer);
   535     return timer.Time2Frames(GetMicroSeconds(), fEngineControl->fBufferSize);
   538 jack_nframes_t JackAlsaDriver::last_frame_time()
 const   541     fEngineControl->ReadFrameTime(&timer);
   542     return timer.CurFrame();
   558     snd_ctl_card_info_t * info;
   559     snd_pcm_info_t * pcminfo_capture;
   560     snd_pcm_info_t * pcminfo_playback;
   564     char description[64];
   569     uint32_t array_size = 0;
   571     snd_ctl_card_info_alloca(&info);
   572     snd_pcm_info_alloca(&pcminfo_capture);
   573     snd_pcm_info_alloca(&pcminfo_playback);
   575     constraint_ptr = NULL;
   577     while(snd_card_next(&card_no) >= 0 && card_no >= 0)
   579         snprintf(card_id.str, 
sizeof(card_id.str), 
"hw:%d", card_no);
   581         if (snd_ctl_open(&handle, card_id.str, 0) >= 0 &&
   582             snd_ctl_card_info(handle, info) >= 0)
   584             snprintf(card_id.str, 
sizeof(card_id.str), 
"hw:%s", snd_ctl_card_info_get_id(info));
   585             if (!jack_constraint_add_enum(
   589                     snd_ctl_card_info_get_name(info)))
   594             while (snd_ctl_pcm_next_device(handle, &device_no) >= 0 && device_no != -1)
   596                 snprintf(device_id.str, 
sizeof(device_id.str), 
"%s,%d", card_id.str, device_no);
   598                 snd_pcm_info_set_device(pcminfo_capture, device_no);
   599                 snd_pcm_info_set_subdevice(pcminfo_capture, 0);
   600                 snd_pcm_info_set_stream(pcminfo_capture, SND_PCM_STREAM_CAPTURE);
   601                 has_capture = snd_ctl_pcm_info(handle, pcminfo_capture) >= 0;
   603                 snd_pcm_info_set_device(pcminfo_playback, device_no);
   604                 snd_pcm_info_set_subdevice(pcminfo_playback, 0);
   605                 snd_pcm_info_set_stream(pcminfo_playback, SND_PCM_STREAM_PLAYBACK);
   606                 has_playback = snd_ctl_pcm_info(handle, pcminfo_playback) >= 0;
   608                 if (has_capture && has_playback)
   610                     snprintf(description, 
sizeof(description),
"%s (duplex)", snd_pcm_info_get_name(pcminfo_capture));
   612                 else if (has_capture)
   614                     snprintf(description, 
sizeof(description),
"%s (capture)", snd_pcm_info_get_name(pcminfo_capture));
   616                 else if (has_playback)
   618                     snprintf(description, 
sizeof(description),
"%s (playback)", snd_pcm_info_get_name(pcminfo_playback));
   625                 if (!jack_constraint_add_enum(
   633             snd_ctl_close(handle);
   637     return constraint_ptr;
   639     jack_constraint_free(constraint_ptr);
   644 dither_opt (
char c, DitherAlgorithm* dither)
   653             *dither = Rectangular;
   661             *dither = Triangular;
   665             fprintf (stderr, 
"ALSA driver: illegal dithering mode %c\n", c);
   677     desc = jack_driver_descriptor_construct(
"alsa", JackDriverMaster, 
"Linux ALSA API based audio backend", &filler);
   679     strcpy(value.str, 
"hw:0");
   681     jack_driver_descriptor_add_parameter(desc, &filler, 
"device", 
'd', JackDriverParamString, &value, NULL, 
"ALSA device name", NULL);
   683     jack_driver_descriptor_add_parameter(desc, &filler, 
"device", 
'd', JackDriverParamString, &value, enum_alsa_devices(), 
"ALSA device name", NULL);
   686     strcpy(value.str, 
"none");
   687     jack_driver_descriptor_add_parameter(desc, &filler, 
"capture", 
'C', JackDriverParamString, &value, NULL, 
"Provide capture ports.  Optionally set device", NULL);
   688     jack_driver_descriptor_add_parameter(desc, &filler, 
"playback", 
'P', JackDriverParamString, &value, NULL, 
"Provide playback ports.  Optionally set device", NULL);
   691     jack_driver_descriptor_add_parameter(desc, &filler, 
"rate", 
'r', JackDriverParamUInt, &value, NULL, 
"Sample rate", NULL);
   694     jack_driver_descriptor_add_parameter(desc, &filler, 
"period", 
'p', JackDriverParamUInt, &value, NULL, 
"Frames per period", NULL);
   697     jack_driver_descriptor_add_parameter(desc, &filler, 
"nperiods", 
'n', JackDriverParamUInt, &value, NULL, 
"Number of periods of playback latency", NULL);
   700     jack_driver_descriptor_add_parameter(desc, &filler, 
"hwmon", 
'H', JackDriverParamBool, &value, NULL, 
"Hardware monitoring, if available", NULL);
   703     jack_driver_descriptor_add_parameter(desc, &filler, 
"hwmeter", 
'M', JackDriverParamBool, &value, NULL, 
"Hardware metering, if available", NULL);
   706     jack_driver_descriptor_add_parameter(desc, &filler, 
"duplex", 
'D', JackDriverParamBool, &value, NULL, 
"Provide both capture and playback ports", NULL);
   709     jack_driver_descriptor_add_parameter(desc, &filler, 
"softmode", 
's', JackDriverParamBool, &value, NULL, 
"Soft-mode, no xrun handling", NULL);
   712     jack_driver_descriptor_add_parameter(desc, &filler, 
"monitor", 
'm', JackDriverParamBool, &value, NULL, 
"Provide monitor ports for the output", NULL);
   715     jack_driver_descriptor_add_parameter(
   722         jack_constraint_compose_enum_char(
   723             JACK_CONSTRAINT_FLAG_STRICT | JACK_CONSTRAINT_FLAG_FAKE_VALUE,
   724             dither_constraint_descr_array),
   729     jack_driver_descriptor_add_parameter(desc, &filler, 
"inchannels", 
'i', JackDriverParamUInt, &value, NULL, 
"Number of capture channels (defaults to hardware max)", NULL);
   730     jack_driver_descriptor_add_parameter(desc, &filler, 
"outchannels", 
'o', JackDriverParamUInt, &value, NULL, 
"Number of playback channels (defaults to hardware max)", NULL);
   733     jack_driver_descriptor_add_parameter(desc, &filler, 
"shorts", 
'S', JackDriverParamBool, &value, NULL, 
"Try 16-bit samples before 32-bit", NULL);
   736     jack_driver_descriptor_add_parameter(desc, &filler, 
"input-latency", 
'I', JackDriverParamUInt, &value, NULL, 
"Extra input latency (frames)", NULL);
   737     jack_driver_descriptor_add_parameter(desc, &filler, 
"output-latency", 
'O', JackDriverParamUInt, &value, NULL, 
"Extra output latency (frames)", NULL);
   739     strcpy(value.str, 
"none");
   740     jack_driver_descriptor_add_parameter(
   745         JackDriverParamString,
   747         jack_constraint_compose_enum_str(
   748             JACK_CONSTRAINT_FLAG_STRICT | JACK_CONSTRAINT_FLAG_FAKE_VALUE,
   749             midi_constraint_descr_array),
   760     jack_nframes_t srate = 48000;
   761     jack_nframes_t frames_per_interrupt = 1024;
   762     unsigned long user_nperiods = 2;
   763     const char *playback_pcm_name = 
"hw:0";
   764     const char *capture_pcm_name = 
"hw:0";
   765     int hw_monitoring = FALSE;
   766     int hw_metering = FALSE;
   768     int playback = FALSE;
   769     int soft_mode = FALSE;
   771     DitherAlgorithm dither = None;
   772     int user_capture_nchnls = 0;
   773     int user_playback_nchnls = 0;
   774     int shorts_first = FALSE;
   775     jack_nframes_t systemic_input_latency = 0;
   776     jack_nframes_t systemic_output_latency = 0;
   779     const char *midi_driver = 
"none";
   781     for (node = params; node; node = jack_slist_next (node)) {
   784         switch (param->character) {
   788                 if (strcmp (param->value.str, 
"none") != 0) {
   789                     capture_pcm_name = strdup (param->value.str);
   790                     jack_log(
"capture device %s", capture_pcm_name);
   796                 if (strcmp (param->value.str, 
"none") != 0) {
   797                     playback_pcm_name = strdup (param->value.str);
   798                     jack_log(
"playback device %s", playback_pcm_name);
   808                 if (strcmp (param->value.str, 
"none") != 0) {
   809                     playback_pcm_name = strdup (param->value.str);
   810                     capture_pcm_name = strdup (param->value.str);
   811                     jack_log(
"playback device %s", playback_pcm_name);
   812                     jack_log(
"capture device %s", capture_pcm_name);
   817                 hw_monitoring = param->value.i;
   821                 monitor = param->value.i;
   825                 hw_metering = param->value.i;
   829                 srate = param->value.ui;
   830                 jack_log(
"apparent rate = %d", srate);
   834                 frames_per_interrupt = param->value.ui;
   835                 jack_log(
"frames per period = %d", frames_per_interrupt);
   839                 user_nperiods = param->value.ui;
   840                 if (user_nperiods < 2) {    
   846                 soft_mode = param->value.i;
   850                 if (dither_opt (param->value.c, &dither)) {
   856                 user_capture_nchnls = param->value.ui;
   860                 user_playback_nchnls = param->value.ui;
   864                 shorts_first = param->value.i;
   868                 systemic_input_latency = param->value.ui;
   872                 systemic_output_latency = param->value.ui;
   876                 midi_driver = strdup(param->value.str);
   882     if (!capture && !playback) {
   890     if (g_alsa_driver->Open(frames_per_interrupt, user_nperiods, srate, hw_monitoring, hw_metering, capture, playback, dither, soft_mode, monitor,
   891                           user_capture_nchnls, user_playback_nchnls, shorts_first, capture_pcm_name, playback_pcm_name,
   892                           systemic_input_latency, systemic_output_latency, midi_driver) == 0) {
   893         return threaded_driver;
   895         delete threaded_driver; 
   902 void ReadInput(jack_nframes_t orig_nframes, snd_pcm_sframes_t contiguous, snd_pcm_sframes_t nread)
   904     g_alsa_driver->ReadInputAux(orig_nframes, contiguous, nread);
   908     g_alsa_driver->MonitorInputAux();
   912     g_alsa_driver->ClearOutputAux();
   914 void WriteOutput(jack_nframes_t orig_nframes, snd_pcm_sframes_t contiguous, snd_pcm_sframes_t nwritten)
   916     g_alsa_driver->WriteOutputAux(orig_nframes, contiguous, nwritten);
   918 void SetTime(jack_time_t time)
   920     g_alsa_driver->SetTimetAux(time);
   926     if ((res = g_alsa_driver->Stop()) == 0) {
   927         res = g_alsa_driver->Start();
 
The base class for threaded drivers using a "decorator" pattern. Threaded drivers are used with block...
Locked Engine, access to methods is serialized using a mutex.
Inter process synchronization using POSIX semaphore.
SERVER_EXPORT void jack_error(const char *fmt,...)
The base interface for drivers clients.
SERVER_EXPORT void jack_log(const char *fmt,...)