34 #include <sys/types.h>    39 #include "JackFFADODriver.h"    40 #include "JackFFADOMidiInputPort.h"    41 #include "JackFFADOMidiOutputPort.h"    42 #include "JackEngineControl.h"    43 #include "JackClientControl.h"    45 #include "JackGraphManager.h"    46 #include "JackCompilerDeps.h"    47 #include "JackLockedEngine.h"    51 #ifndef FFADO_API_VERSION    52 extern "C" int ffado_streaming_set_period_size(ffado_device_t *dev,
    53                 unsigned int period) __attribute__((__weak__));
    61 #define FIREWIRE_REQUIRED_FFADO_API_VERSION 8    62 #define FIREWIRE_REQUIRED_FFADO_API_VERSION_FOR_SETBUFSIZE 9    64 #define jack_get_microseconds GetMicroSeconds    67 JackFFADODriver::ffado_driver_read (
ffado_driver_t * driver, jack_nframes_t nframes)
    70     jack_default_audio_sample_t* buf = NULL;
    73     for (chn = 0; chn < driver->capture_nchannels; chn++) {
    75         if (fGraphManager->GetConnectionsNum(fCapturePortList[chn]) == 0) {
    76             buf = (jack_default_audio_sample_t*)driver->scratchbuffer;
    78             ffado_streaming_set_capture_stream_buffer(driver->dev, chn, (
char *)(buf));
    81             ffado_streaming_capture_stream_onoff(driver->dev, chn, 0);
    83             if (driver->capture_channels[chn].stream_type == ffado_stream_type_audio) {
    84                 buf = (jack_default_audio_sample_t*)fGraphManager->GetBuffer(fCapturePortList[chn],  nframes);
    87                 if (!buf) buf = (jack_default_audio_sample_t*)driver->scratchbuffer;
    89                 ffado_streaming_set_capture_stream_buffer(driver->dev, chn, (
char *)(buf));
    90                 ffado_streaming_capture_stream_onoff(driver->dev, chn, 1);
    91             } 
else if (driver->capture_channels[chn].stream_type == ffado_stream_type_midi) {
    92                 ffado_streaming_set_capture_stream_buffer(driver->dev, chn,
    93                         (
char *)(driver->capture_channels[chn].midi_buffer));
    94                 ffado_streaming_capture_stream_onoff(driver->dev, chn, 1);
    96                 ffado_streaming_set_capture_stream_buffer(driver->dev, chn, (
char *)(driver->scratchbuffer));
    98                 ffado_streaming_capture_stream_onoff(driver->dev, chn, 0);
   104     ffado_streaming_transfer_capture_buffers(driver->dev);
   107     for (chn = 0; chn < driver->capture_nchannels; chn++) {
   108         if (driver->capture_channels[chn].stream_type == ffado_stream_type_midi) {
   109             JackFFADOMidiInputPort *midi_input = (JackFFADOMidiInputPort *) driver->capture_channels[chn].midi_input;
   110             JackMidiBuffer *buffer = (JackMidiBuffer *) fGraphManager->GetBuffer(fCapturePortList[chn], nframes);
   111             midi_input->Process(buffer, driver->capture_channels[chn].midi_buffer, nframes);
   120 JackFFADODriver::ffado_driver_write (
ffado_driver_t * driver, jack_nframes_t nframes)
   123     jack_default_audio_sample_t* buf;
   126     driver->process_count++;
   128     for (chn = 0; chn < driver->playback_nchannels; chn++) {
   129         if (fGraphManager->GetConnectionsNum(fPlaybackPortList[chn]) == 0) {
   130             buf = (jack_default_audio_sample_t*)driver->nullbuffer;
   132             ffado_streaming_set_playback_stream_buffer(driver->dev, chn, (
char *)(buf));
   135             ffado_streaming_playback_stream_onoff(driver->dev, chn, 0);
   137             if (driver->playback_channels[chn].stream_type == ffado_stream_type_audio) {
   138                 buf = (jack_default_audio_sample_t*)fGraphManager->GetBuffer(fPlaybackPortList[chn], nframes);
   140                 if (!buf) buf = (jack_default_audio_sample_t*)driver->nullbuffer;
   141                 ffado_streaming_set_playback_stream_buffer(driver->dev, chn, (
char *)(buf));
   142                 ffado_streaming_playback_stream_onoff(driver->dev, chn, 1);
   143             } 
else if (driver->playback_channels[chn].stream_type == ffado_stream_type_midi) {
   144                 uint32_t *midi_buffer = driver->playback_channels[chn].midi_buffer;
   145                 memset(midi_buffer, 0, nframes * 
sizeof(uint32_t));
   146                 buf = (jack_default_audio_sample_t *) fGraphManager->GetBuffer(fPlaybackPortList[chn], nframes);
   147                 ffado_streaming_set_playback_stream_buffer(driver->dev, chn, (
char *)(midi_buffer));
   148                 ffado_streaming_playback_stream_onoff(driver->dev, chn, buf ? 1 : 0);
   149                 JackFFADOMidiOutputPort *midi_output = (JackFFADOMidiOutputPort *) driver->playback_channels[chn].midi_output;
   150                 midi_output->Process((JackMidiBuffer *) buf, midi_buffer, nframes);
   153                 ffado_streaming_set_playback_stream_buffer(driver->dev, chn, (
char *)(driver->nullbuffer));
   154                 ffado_streaming_playback_stream_onoff(driver->dev, chn, 0);
   158     ffado_streaming_transfer_playback_buffers(driver->dev);
   164 JackFFADODriver::ffado_driver_wait (
ffado_driver_t *driver, 
int extra_fd, 
int *status,
   165                                     float *delayed_usecs)
   167     jack_time_t wait_enter;
   168     jack_time_t wait_ret;
   169     ffado_wait_response response;
   173     wait_enter = jack_get_microseconds ();
   174     if (wait_enter > driver->wait_next) {
   180         driver->wait_next = 0;
   187     response = ffado_streaming_wait(driver->dev);
   189     wait_ret = jack_get_microseconds ();
   191     if (driver->wait_next && wait_ret > driver->wait_next) {
   192         *delayed_usecs = wait_ret - driver->wait_next;
   194     driver->wait_last = wait_ret;
   195     driver->wait_next = wait_ret + driver->period_usecs;
   198     if(response == ffado_wait_ok) {
   201     } 
else if (response == ffado_wait_xrun) {
   205     } 
else if (response == ffado_wait_error) {
   208         jack_error(
"JackFFADODriver::ffado_driver_wait - unhandled xrun");
   211     } 
else if (response == ffado_wait_shutdown) {
   214         jack_error(
"JackFFADODriver::ffado_driver_wait - shutdown requested "   215                    "(device unplugged?)");
   221         jack_error(
"JackFFADODriver::ffado_driver_wait - unexpected error "   222                    "code '%d' returned from 'ffado_streaming_wait'", response);
   227     fBeginDateUst = wait_ret;
   230     return driver->period_size;
   238     if ((retval = ffado_streaming_start(driver->dev))) {
   239         printError(
"Could not start streaming threads");
   251     if ((retval = ffado_streaming_stop(driver->dev))) {
   252         printError(
"Could not stop streaming threads");
   268 JackFFADODriver::UpdateLatencies(
void)
   273     for (
int i = 0; i < fCaptureChannels; i++) {
   274         range.
min = range.
max = driver->period_size + driver->capture_frame_latency;
   275         fGraphManager->GetPort(fCapturePortList[i])->SetLatencyRange(JackCaptureLatency, &range);
   278     for (
int i = 0; i < fPlaybackChannels; i++) {
   280         range.
min = range.
max = (driver->period_size *
   281                         (driver->device_options.nb_buffers - 1)) +
   282                          ((fEngineControl->fSyncMode) ? 0 : fEngineControl->fBufferSize) + driver->playback_frame_latency;
   283         fGraphManager->GetPort(fPlaybackPortList[i])->SetLatencyRange(JackPlaybackLatency, &range);
   285         if (fWithMonitorPorts) {
   286             range.
min = range.
max =driver->period_size;
   287             fGraphManager->GetPort(fMonitorPortList[i])->SetLatencyRange(JackCaptureLatency, &range);
   293 JackFFADODriver::SetBufferSize (jack_nframes_t nframes)
   300     if (ffado_get_api_version() < FIREWIRE_REQUIRED_FFADO_API_VERSION_FOR_SETBUFSIZE ||
   301                     ffado_streaming_set_period_size == NULL) {
   302             printError(
"unsupported on current version of FFADO; please upgrade FFADO");
   306     driver->period_size = nframes;
   307     driver->period_usecs =
   308             (jack_time_t) floor ((((
float) nframes) / driver->sample_rate)
   313     driver->nullbuffer = (ffado_sample_t*) calloc(driver->period_size, 
sizeof(ffado_sample_t));
   314     if(driver->nullbuffer == NULL) {
   315             printError(
"could not allocate memory for null buffer");
   318     driver->scratchbuffer = (ffado_sample_t*) calloc(driver->period_size, 
sizeof(ffado_sample_t));
   319     if(driver->scratchbuffer == NULL) {
   320             printError(
"could not allocate memory for scratch buffer");
   325     for (chn = 0; chn < driver->capture_nchannels; chn++) {
   326             if(driver->capture_channels[chn].stream_type == ffado_stream_type_midi) {
   328                     if (driver->capture_channels[chn].midi_buffer != NULL)
   329                             free(driver->capture_channels[chn].midi_buffer);
   330                     driver->capture_channels[chn].midi_buffer = (ffado_sample_t*) calloc(driver->period_size, 
sizeof(uint32_t));
   333     for (chn = 0; chn < driver->playback_nchannels; chn++) {
   334             if(driver->playback_channels[chn].stream_type == ffado_stream_type_midi) {
   335                     if (driver->playback_channels[chn].midi_buffer != NULL)
   336                             free(driver->playback_channels[chn].midi_buffer);
   337                     driver->playback_channels[chn].midi_buffer = (ffado_sample_t*) calloc(driver->period_size, 
sizeof(uint32_t));
   342     if (ffado_streaming_set_period_size(driver->dev, nframes) != 0) {
   343             printError(
"could not alter FFADO device period size");
   352     JackAudioDriver::SetBufferSize(nframes);  
   362 JackFFADODriver::ffado_driver_new (
const char *name,
   369     if (ffado_get_api_version() < FIREWIRE_REQUIRED_FFADO_API_VERSION) {
   370         printError(
"Incompatible libffado version! (%s)", ffado_get_version());
   374     printMessage(
"Starting FFADO backend (%s)", ffado_get_version());
   396     driver->sample_rate = params->sample_rate;
   397     driver->period_size = params->period_size;
   400     driver->period_usecs =
   401         (jack_time_t) floor ((((
float) driver->period_size) * 1000000.0f) / driver->sample_rate);
   404     driver->engine = NULL;
   407     driver->device_info.nb_device_spec_strings=1;
   408     driver->device_info.device_spec_strings=(
char**)calloc(1, 
sizeof(
char *));
   409     driver->device_info.device_spec_strings[0]=strdup(params->device_info);
   411     memset(&driver->device_options, 0, 
sizeof(driver->device_options));
   412     driver->device_options.sample_rate = params->sample_rate;
   413     driver->device_options.period_size = params->period_size;
   414     driver->device_options.nb_buffers = params->buffer_size;
   415     driver->device_options.verbose = params->verbose_level;
   416     driver->capture_frame_latency = params->capture_frame_latency;
   417     driver->playback_frame_latency = params->playback_frame_latency;
   418     driver->device_options.snoop_mode = params->snoop_mode;
   420     debugPrint(DEBUG_LEVEL_STARTUP, 
" Driver compiled on %s %s", __DATE__, __TIME__);
   421     debugPrint(DEBUG_LEVEL_STARTUP, 
" Created driver %s", name);
   422     debugPrint(DEBUG_LEVEL_STARTUP, 
"            period_size:   %d", driver->device_options.period_size);
   423     debugPrint(DEBUG_LEVEL_STARTUP, 
"            period_usecs:  %d", driver->period_usecs);
   424     debugPrint(DEBUG_LEVEL_STARTUP, 
"            sample rate:   %d", driver->device_options.sample_rate);
   425     debugPrint(DEBUG_LEVEL_STARTUP, 
"            verbose level: %d", driver->device_options.verbose);
   436 int JackFFADODriver::Attach()
   439     jack_port_id_t port_index;
   440     char buf[REAL_JACK_PORT_NAME_SIZE];
   441     char portname[REAL_JACK_PORT_NAME_SIZE];
   445     jack_log(
"JackFFADODriver::Attach fBufferSize %ld fSampleRate %ld", fEngineControl->fBufferSize, fEngineControl->fSampleRate);
   447     g_verbose = (fEngineControl->fVerbose ? 1 : 0);
   453     driver->nullbuffer = (ffado_sample_t *)calloc(driver->period_size, 
sizeof(ffado_sample_t));
   454     if (driver->nullbuffer == NULL) {
   455         printError(
"could not allocate memory for null buffer");
   459     memset(driver->nullbuffer, 0, driver->period_size*
sizeof(ffado_sample_t));
   462     driver->scratchbuffer = (ffado_sample_t *)calloc(driver->period_size, 
sizeof(ffado_sample_t));
   463     if (driver->scratchbuffer == NULL) {
   464         printError(
"could not allocate memory for scratch buffer");
   469     driver->device_options.realtime = (fEngineControl->fRealTime ? 1 : 0);
   471     driver->device_options.packetizer_priority = fEngineControl->fServerPriority +
   472             FFADO_RT_PRIORITY_PACKETIZER_RELATIVE;
   473     if (driver->device_options.packetizer_priority > 98) {
   474         driver->device_options.packetizer_priority = 98;
   478     driver->dev = ffado_streaming_init(driver->device_info, driver->device_options);
   481         printError(
"FFADO: Error creating virtual device");
   485     if (driver->device_options.realtime) {
   486         printMessage(
"Streaming thread running with Realtime scheduling, priority %d",
   487                      driver->device_options.packetizer_priority);
   489         printMessage(
"Streaming thread running without Realtime scheduling");
   492     ffado_streaming_set_audio_datatype(driver->dev, ffado_audio_datatype_float);
   497     driver->capture_nchannels = ffado_streaming_get_nb_capture_streams(driver->dev);
   499     if (driver->capture_channels == NULL) {
   500         printError(
"could not allocate memory for capture channel list");
   504     fCaptureChannels = 0;
   505     for (channel_t chn = 0; chn < driver->capture_nchannels; chn++) {
   506         ffado_streaming_get_capture_stream_name(driver->dev, chn, portname, 
sizeof(portname));
   508         driver->capture_channels[chn].stream_type = ffado_streaming_get_capture_stream_type(driver->dev, chn);
   509         if (driver->capture_channels[chn].stream_type == ffado_stream_type_audio) {
   510             snprintf(buf, 
sizeof(buf), 
"firewire_pcm:%s_in", portname);
   511             printMessage (
"Registering audio capture port %s", buf);
   512             if (fEngine->PortRegister(fClientControl.fRefNum, buf,
   513                               JACK_DEFAULT_AUDIO_TYPE,
   515                               fEngineControl->fBufferSize, &port_index) < 0) {
   516                 jack_error(
"driver: cannot register port for %s", buf);
   521             if (ffado_streaming_set_capture_stream_buffer(driver->dev, chn, NULL)) {
   522                 printError(
" cannot configure initial port buffer for %s", buf);
   524             ffado_streaming_capture_stream_onoff(driver->dev, chn, 0);
   526             port = fGraphManager->GetPort(port_index);
   528             snprintf(buf, 
sizeof(buf), 
"%s:capture_%i", fClientControl.fName, (
int) chn + 1);
   530             fCapturePortList[chn] = port_index;
   531             jack_log(
"JackFFADODriver::Attach fCapturePortList[i] %ld ", port_index);
   533         } 
else if (driver->capture_channels[chn].stream_type == ffado_stream_type_midi) {
   534             snprintf(buf, 
sizeof(buf), 
"firewire_pcm:%s_in", portname);
   535             printMessage (
"Registering midi capture port %s", buf);
   536             if (fEngine->PortRegister(fClientControl.fRefNum, buf,
   537                               JACK_DEFAULT_MIDI_TYPE,
   539                               fEngineControl->fBufferSize, &port_index) < 0) {
   540                 jack_error(
"driver: cannot register port for %s", buf);
   545             if (ffado_streaming_set_capture_stream_buffer(driver->dev, chn, NULL)) {
   546                 printError(
" cannot configure initial port buffer for %s", buf);
   548             if (ffado_streaming_capture_stream_onoff(driver->dev, chn, 0)) {
   549                 printError(
" cannot enable port %s", buf);
   552             driver->capture_channels[chn].midi_input = 
new JackFFADOMidiInputPort();
   554             driver->capture_channels[chn].midi_buffer = (uint32_t *)calloc(driver->period_size, 
sizeof(uint32_t));
   556             fCapturePortList[chn] = port_index;
   557             jack_log(
"JackFFADODriver::Attach fCapturePortList[i] %ld ", port_index);
   560             printMessage (
"Don't register capture port %s", portname);
   565     driver->playback_nchannels = ffado_streaming_get_nb_playback_streams(driver->dev);
   567     if (driver->playback_channels == NULL) {
   568         printError(
"could not allocate memory for playback channel list");
   572     fPlaybackChannels = 0;
   573     for (channel_t chn = 0; chn < driver->playback_nchannels; chn++) {
   574         ffado_streaming_get_playback_stream_name(driver->dev, chn, portname, 
sizeof(portname));
   576         driver->playback_channels[chn].stream_type = ffado_streaming_get_playback_stream_type(driver->dev, chn);
   578         if (driver->playback_channels[chn].stream_type == ffado_stream_type_audio) {
   579             snprintf(buf, 
sizeof(buf), 
"firewire_pcm:%s_out", portname);
   580             printMessage (
"Registering audio playback port %s", buf);
   581             if (fEngine->PortRegister(fClientControl.fRefNum, buf,
   582                               JACK_DEFAULT_AUDIO_TYPE,
   584                               fEngineControl->fBufferSize, &port_index) < 0) {
   585                 jack_error(
"driver: cannot register port for %s", buf);
   590             if (ffado_streaming_set_playback_stream_buffer(driver->dev, chn, NULL)) {
   591                 printError(
" cannot configure initial port buffer for %s", buf);
   593             if (ffado_streaming_playback_stream_onoff(driver->dev, chn, 0)) {
   594                 printError(
" cannot enable port %s", buf);
   597             port = fGraphManager->GetPort(port_index);
   600             snprintf(buf, 
sizeof(buf), 
"%s:playback_%i", fClientControl.fName, (
int) chn + 1);
   602             fPlaybackPortList[chn] = port_index;
   603             jack_log(
"JackFFADODriver::Attach fPlaybackPortList[i] %ld ", port_index);
   605         } 
else if (driver->playback_channels[chn].stream_type == ffado_stream_type_midi) {
   606             snprintf(buf, 
sizeof(buf), 
"firewire_pcm:%s_out", portname);
   607             printMessage (
"Registering midi playback port %s", buf);
   609             if (fEngine->PortRegister(fClientControl.fRefNum, buf,
   610                               JACK_DEFAULT_MIDI_TYPE,
   612                               fEngineControl->fBufferSize, &port_index) < 0) {
   613                 jack_error(
"driver: cannot register port for %s", buf);
   618             if (ffado_streaming_set_playback_stream_buffer(driver->dev, chn, NULL)) {
   619                 printError(
" cannot configure initial port buffer for %s", buf);
   621             if (ffado_streaming_playback_stream_onoff(driver->dev, chn, 0)) {
   622                 printError(
" cannot enable port %s", buf);
   629             driver->playback_channels[chn].midi_output = 
new JackFFADOMidiOutputPort();
   631             driver->playback_channels[chn].midi_buffer = (uint32_t *)calloc(driver->period_size, 
sizeof(uint32_t));
   633             fPlaybackPortList[chn] = port_index;
   634             jack_log(
"JackFFADODriver::Attach fPlaybackPortList[i] %ld ", port_index);
   637             printMessage (
"Don't register playback port %s", portname);
   643     assert(fCaptureChannels < DRIVER_PORT_NUM);
   644     assert(fPlaybackChannels < DRIVER_PORT_NUM);
   646     if (ffado_streaming_prepare(driver->dev)) {
   647         printError(
"Could not prepare streaming device!");
   652     assert(fCaptureChannels + fPlaybackChannels > 0);
   656 int JackFFADODriver::Detach()
   660     jack_log(
"JackFFADODriver::Detach");
   663     ffado_streaming_finish(driver->dev);
   667     for (chn = 0; chn < driver->capture_nchannels; chn++) {
   668         if (driver->capture_channels[chn].midi_buffer)
   669             free(driver->capture_channels[chn].midi_buffer);
   670         if (driver->capture_channels[chn].midi_input)
   671             delete ((JackFFADOMidiInputPort *) (driver->capture_channels[chn].midi_input));
   673     free(driver->capture_channels);
   675     for (chn = 0; chn < driver->playback_nchannels; chn++) {
   676         if (driver->playback_channels[chn].midi_buffer)
   677             free(driver->playback_channels[chn].midi_buffer);
   678         if (driver->playback_channels[chn].midi_output)
   679             delete ((JackFFADOMidiOutputPort *) (driver->playback_channels[chn].midi_output));
   681     free(driver->playback_channels);
   683     free(driver->nullbuffer);
   684     free(driver->scratchbuffer);
   686     return JackAudioDriver::Detach();  
   692     if (JackAudioDriver::Open(
   693                 params->period_size, params->sample_rate,
   694                 params->playback_ports, params->playback_ports,
   696                 params->capture_frame_latency, params->playback_frame_latency) != 0) {
   700     fDriver = (
jack_driver_t *)ffado_driver_new (
"ffado_pcm", params);
   708         JackAudioDriver::Close();
   713 int JackFFADODriver::Close()
   716     int res = JackAudioDriver::Close();
   722 int JackFFADODriver::Start()
   724     int res = JackAudioDriver::Start();
   728             JackAudioDriver::Stop();
   734 int JackFFADODriver::Stop()
   737     if (JackAudioDriver::Stop() < 0) {
   743 int JackFFADODriver::Read()
   754     jack_nframes_t nframes = ffado_driver_wait(driver, -1, &wait_status,
   757     if ((wait_status < 0)) {
   758         printError( 
"wait status < 0! (= %d)", wait_status);
   767         NotifyXRun(fBeginDateUst, fDelayedUsecs);
   771     if (nframes != fEngineControl->fBufferSize)
   772         jack_log(
"JackFFADODriver::Read warning nframes = %ld", nframes);
   775     JackDriver::CycleIncTime();
   778     return ffado_driver_read((
ffado_driver_t *)fDriver, fEngineControl->fBufferSize);
   781 int JackFFADODriver::Write()
   784     int res = ffado_driver_write((
ffado_driver_t *)fDriver, fEngineControl->fBufferSize);
   792     memset (driver, 0, 
sizeof (*driver));
   798     driver->null_cycle = 0;
   807     memset (driver, 0, 
sizeof (*driver));
   817     driver->nt_bufsize = 0;
   818     driver->nt_start = 0;
   820     driver->nt_attach = 0;
   821     driver->nt_detach = 0;
   822     driver->nt_run_cycle = 0;
   834     driver_get_descriptor () {
   839         desc = jack_driver_descriptor_construct(
"firewire", JackDriverMaster, 
"Linux FFADO API based audio backend", &filler);
   841         strcpy(value.str, 
"hw:0");
   842         jack_driver_descriptor_add_parameter(
   847             JackDriverParamString,
   850             "The FireWire device to use.",
   851             "The FireWire device to use. Please consult the FFADO documentation for more info.");
   854         jack_driver_descriptor_add_parameter(desc, &filler, 
"period", 
'p', JackDriverParamUInt, &value, NULL, 
"Frames per period", NULL);
   857         jack_driver_descriptor_add_parameter(desc, &filler, 
"nperiods", 
'n', JackDriverParamUInt, &value, NULL, 
"Number of periods of playback latency", NULL);
   860         jack_driver_descriptor_add_parameter(desc, &filler, 
"rate", 
'r', JackDriverParamUInt, &value, NULL, 
"Sample rate", NULL);
   863         jack_driver_descriptor_add_parameter(desc, &filler, 
"capture", 
'C', JackDriverParamBool, &value, NULL, 
"Provide capture ports.", NULL);
   864         jack_driver_descriptor_add_parameter(desc, &filler, 
"playback", 
'P', JackDriverParamBool, &value, NULL, 
"Provide playback ports.", NULL);
   867         jack_driver_descriptor_add_parameter(desc, &filler, 
"duplex", 
'D', JackDriverParamBool, &value, NULL, 
"Provide both capture and playback ports.", NULL);
   870         jack_driver_descriptor_add_parameter(desc, &filler, 
"input-latency", 
'I', JackDriverParamUInt, &value, NULL, 
"Extra input latency (frames)", NULL);
   871         jack_driver_descriptor_add_parameter(desc, &filler, 
"output-latency", 
'O', JackDriverParamUInt, &value, NULL, 
"Extra output latency (frames)", NULL);
   874         jack_driver_descriptor_add_parameter(desc, &filler, 
"inchannels", 
'i', JackDriverParamUInt, &value, NULL, 
"Number of input channels to provide (note: currently ignored)", NULL);
   875         jack_driver_descriptor_add_parameter(desc, &filler, 
"outchannels", 
'o', JackDriverParamUInt, &value, NULL, 
"Number of output channels to provide (note: currently ignored)", NULL);
   878         jack_driver_descriptor_add_parameter(desc, &filler, 
"verbose", 
'v', JackDriverParamUInt, &value, NULL, 
"libffado verbose level", NULL);
   881         jack_driver_descriptor_add_parameter(desc, &filler, 
"snoop", 
'X', JackDriverParamBool, &value, NULL, 
"Snoop firewire traffic", NULL);
   892         char *device_name=(
char*)
"hw:0";
   894         cmlparams.period_size_set = 0;
   895         cmlparams.sample_rate_set = 0;
   896         cmlparams.buffer_size_set = 0;
   899         cmlparams.period_size = 1024;
   900         cmlparams.sample_rate = 48000;
   901         cmlparams.buffer_size = 3;
   902         cmlparams.playback_ports = 0;
   903         cmlparams.capture_ports = 0;
   904         cmlparams.playback_frame_latency = 0;
   905         cmlparams.capture_frame_latency = 0;
   907         cmlparams.verbose_level = 0;
   909         cmlparams.slave_mode = 0;
   910         cmlparams.snoop_mode = 0;
   911         cmlparams.device_info = NULL;
   913         for (node = params; node; node = jack_slist_next (node)) {
   916             switch (param->character) {
   918                     device_name = const_cast<char*>(param->value.str);
   921                     cmlparams.period_size = param->value.ui;
   922                     cmlparams.period_size_set = 1;
   925                     cmlparams.buffer_size = param->value.ui;
   926                     cmlparams.buffer_size_set = 1;
   929                     cmlparams.sample_rate = param->value.ui;
   930                     cmlparams.sample_rate_set = 1;
   933                     cmlparams.capture_ports = param->value.ui;
   936                     cmlparams.playback_ports = param->value.ui;
   939                     cmlparams.capture_frame_latency = param->value.ui;
   942                     cmlparams.playback_frame_latency = param->value.ui;
   945                     cmlparams.slave_mode = param->value.ui;
   948                     cmlparams.snoop_mode = param->value.i;
   951                     cmlparams.verbose_level = param->value.ui;
   956         if (!cmlparams.playback_ports && !cmlparams.capture_ports) {
   957             cmlparams.playback_ports = 1;
   958             cmlparams.capture_ports = 1;
   962         cmlparams.device_info = device_name;
   967         if (ffado_driver->Open(&cmlparams) == 0) {
   968             return threaded_driver;
   970             delete threaded_driver; 
 
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,...)