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;
406 memset(&driver->device_options, 0,
sizeof(driver->device_options));
407 driver->device_options.sample_rate = params->sample_rate;
408 driver->device_options.period_size = params->period_size;
409 driver->device_options.nb_buffers = params->buffer_size;
410 driver->device_options.verbose = params->verbose_level;
411 driver->capture_frame_latency = params->capture_frame_latency;
412 driver->playback_frame_latency = params->playback_frame_latency;
413 driver->device_options.snoop_mode = params->snoop_mode;
415 debugPrint(DEBUG_LEVEL_STARTUP,
" Driver compiled on %s %s", __DATE__, __TIME__);
416 debugPrint(DEBUG_LEVEL_STARTUP,
" Created driver %s", name);
417 debugPrint(DEBUG_LEVEL_STARTUP,
" period_size: %d", driver->device_options.period_size);
418 debugPrint(DEBUG_LEVEL_STARTUP,
" period_usecs: %d", driver->period_usecs);
419 debugPrint(DEBUG_LEVEL_STARTUP,
" sample rate: %d", driver->device_options.sample_rate);
420 debugPrint(DEBUG_LEVEL_STARTUP,
" verbose level: %d", driver->device_options.verbose);
431 int JackFFADODriver::Attach()
434 jack_port_id_t port_index;
435 char buf[REAL_JACK_PORT_NAME_SIZE];
436 char portname[REAL_JACK_PORT_NAME_SIZE];
440 jack_log(
"JackFFADODriver::Attach fBufferSize %ld fSampleRate %ld", fEngineControl->fBufferSize, fEngineControl->fSampleRate);
442 g_verbose = (fEngineControl->fVerbose ? 1 : 0);
448 driver->nullbuffer = (ffado_sample_t *)calloc(driver->period_size,
sizeof(ffado_sample_t));
449 if (driver->nullbuffer == NULL) {
450 printError(
"could not allocate memory for null buffer");
454 memset(driver->nullbuffer, 0, driver->period_size*
sizeof(ffado_sample_t));
457 driver->scratchbuffer = (ffado_sample_t *)calloc(driver->period_size,
sizeof(ffado_sample_t));
458 if (driver->scratchbuffer == NULL) {
459 printError(
"could not allocate memory for scratch buffer");
464 driver->device_options.realtime = (fEngineControl->fRealTime ? 1 : 0);
466 driver->device_options.packetizer_priority = fEngineControl->fServerPriority +
467 FFADO_RT_PRIORITY_PACKETIZER_RELATIVE;
468 if (driver->device_options.packetizer_priority > 98) {
469 driver->device_options.packetizer_priority = 98;
473 driver->dev = ffado_streaming_init(driver->device_info, driver->device_options);
476 printError(
"FFADO: Error creating virtual device");
480 if (driver->device_options.realtime) {
481 printMessage(
"Streaming thread running with Realtime scheduling, priority %d",
482 driver->device_options.packetizer_priority);
484 printMessage(
"Streaming thread running without Realtime scheduling");
487 ffado_streaming_set_audio_datatype(driver->dev, ffado_audio_datatype_float);
492 driver->capture_nchannels = ffado_streaming_get_nb_capture_streams(driver->dev);
494 if (driver->capture_channels == NULL) {
495 printError(
"could not allocate memory for capture channel list");
499 fCaptureChannels = 0;
500 for (channel_t chn = 0; chn < driver->capture_nchannels; chn++) {
501 ffado_streaming_get_capture_stream_name(driver->dev, chn, portname,
sizeof(portname));
503 driver->capture_channels[chn].stream_type = ffado_streaming_get_capture_stream_type(driver->dev, chn);
504 if (driver->capture_channels[chn].stream_type == ffado_stream_type_audio) {
505 snprintf(buf,
sizeof(buf),
"firewire_pcm:%s_in", portname);
506 printMessage (
"Registering audio capture port %s", buf);
507 if (fEngine->PortRegister(fClientControl.fRefNum, buf,
508 JACK_DEFAULT_AUDIO_TYPE,
510 fEngineControl->fBufferSize, &port_index) < 0) {
511 jack_error(
"driver: cannot register port for %s", buf);
516 if (ffado_streaming_set_capture_stream_buffer(driver->dev, chn, NULL)) {
517 printError(
" cannot configure initial port buffer for %s", buf);
519 ffado_streaming_capture_stream_onoff(driver->dev, chn, 0);
521 port = fGraphManager->GetPort(port_index);
523 snprintf(buf,
sizeof(buf),
"%s:capture_%i", fClientControl.fName, (
int) chn + 1);
525 fCapturePortList[chn] = port_index;
526 jack_log(
"JackFFADODriver::Attach fCapturePortList[i] %ld ", port_index);
528 }
else if (driver->capture_channels[chn].stream_type == ffado_stream_type_midi) {
529 snprintf(buf,
sizeof(buf),
"firewire_pcm:%s_in", portname);
530 printMessage (
"Registering midi capture port %s", buf);
531 if (fEngine->PortRegister(fClientControl.fRefNum, buf,
532 JACK_DEFAULT_MIDI_TYPE,
534 fEngineControl->fBufferSize, &port_index) < 0) {
535 jack_error(
"driver: cannot register port for %s", buf);
540 if (ffado_streaming_set_capture_stream_buffer(driver->dev, chn, NULL)) {
541 printError(
" cannot configure initial port buffer for %s", buf);
543 if (ffado_streaming_capture_stream_onoff(driver->dev, chn, 0)) {
544 printError(
" cannot enable port %s", buf);
547 driver->capture_channels[chn].midi_input =
new JackFFADOMidiInputPort();
549 driver->capture_channels[chn].midi_buffer = (uint32_t *)calloc(driver->period_size,
sizeof(uint32_t));
551 fCapturePortList[chn] = port_index;
552 jack_log(
"JackFFADODriver::Attach fCapturePortList[i] %ld ", port_index);
555 printMessage (
"Don't register capture port %s", portname);
560 driver->playback_nchannels = ffado_streaming_get_nb_playback_streams(driver->dev);
562 if (driver->playback_channels == NULL) {
563 printError(
"could not allocate memory for playback channel list");
567 fPlaybackChannels = 0;
568 for (channel_t chn = 0; chn < driver->playback_nchannels; chn++) {
569 ffado_streaming_get_playback_stream_name(driver->dev, chn, portname,
sizeof(portname));
571 driver->playback_channels[chn].stream_type = ffado_streaming_get_playback_stream_type(driver->dev, chn);
573 if (driver->playback_channels[chn].stream_type == ffado_stream_type_audio) {
574 snprintf(buf,
sizeof(buf),
"firewire_pcm:%s_out", portname);
575 printMessage (
"Registering audio playback port %s", buf);
576 if (fEngine->PortRegister(fClientControl.fRefNum, buf,
577 JACK_DEFAULT_AUDIO_TYPE,
579 fEngineControl->fBufferSize, &port_index) < 0) {
580 jack_error(
"driver: cannot register port for %s", buf);
585 if (ffado_streaming_set_playback_stream_buffer(driver->dev, chn, NULL)) {
586 printError(
" cannot configure initial port buffer for %s", buf);
588 if (ffado_streaming_playback_stream_onoff(driver->dev, chn, 0)) {
589 printError(
" cannot enable port %s", buf);
592 port = fGraphManager->GetPort(port_index);
595 snprintf(buf,
sizeof(buf),
"%s:playback_%i", fClientControl.fName, (
int) chn + 1);
597 fPlaybackPortList[chn] = port_index;
598 jack_log(
"JackFFADODriver::Attach fPlaybackPortList[i] %ld ", port_index);
600 }
else if (driver->playback_channels[chn].stream_type == ffado_stream_type_midi) {
601 snprintf(buf,
sizeof(buf),
"firewire_pcm:%s_out", portname);
602 printMessage (
"Registering midi playback port %s", buf);
604 if (fEngine->PortRegister(fClientControl.fRefNum, buf,
605 JACK_DEFAULT_MIDI_TYPE,
607 fEngineControl->fBufferSize, &port_index) < 0) {
608 jack_error(
"driver: cannot register port for %s", buf);
613 if (ffado_streaming_set_playback_stream_buffer(driver->dev, chn, NULL)) {
614 printError(
" cannot configure initial port buffer for %s", buf);
616 if (ffado_streaming_playback_stream_onoff(driver->dev, chn, 0)) {
617 printError(
" cannot enable port %s", buf);
624 driver->playback_channels[chn].midi_output =
new JackFFADOMidiOutputPort();
626 driver->playback_channels[chn].midi_buffer = (uint32_t *)calloc(driver->period_size,
sizeof(uint32_t));
628 fPlaybackPortList[chn] = port_index;
629 jack_log(
"JackFFADODriver::Attach fPlaybackPortList[i] %ld ", port_index);
632 printMessage (
"Don't register playback port %s", portname);
638 assert(fCaptureChannels < DRIVER_PORT_NUM);
639 assert(fPlaybackChannels < DRIVER_PORT_NUM);
641 if (ffado_streaming_prepare(driver->dev)) {
642 printError(
"Could not prepare streaming device!");
647 assert(fCaptureChannels + fPlaybackChannels > 0);
651 int JackFFADODriver::Detach()
655 jack_log(
"JackFFADODriver::Detach");
658 ffado_streaming_finish(driver->dev);
662 for (chn = 0; chn < driver->capture_nchannels; chn++) {
663 if (driver->capture_channels[chn].midi_buffer)
664 free(driver->capture_channels[chn].midi_buffer);
665 if (driver->capture_channels[chn].midi_input)
666 delete ((JackFFADOMidiInputPort *) (driver->capture_channels[chn].midi_input));
668 free(driver->capture_channels);
670 for (chn = 0; chn < driver->playback_nchannels; chn++) {
671 if (driver->playback_channels[chn].midi_buffer)
672 free(driver->playback_channels[chn].midi_buffer);
673 if (driver->playback_channels[chn].midi_output)
674 delete ((JackFFADOMidiOutputPort *) (driver->playback_channels[chn].midi_output));
676 free(driver->playback_channels);
678 free(driver->nullbuffer);
679 free(driver->scratchbuffer);
681 return JackAudioDriver::Detach();
687 if (JackAudioDriver::Open(
688 params->period_size, params->sample_rate,
689 params->playback_ports, params->playback_ports,
691 params->capture_frame_latency, params->playback_frame_latency) != 0) {
695 fDriver = (
jack_driver_t *)ffado_driver_new (
"ffado_pcm", params);
703 JackAudioDriver::Close();
708 int JackFFADODriver::Close()
711 int res = JackAudioDriver::Close();
717 int JackFFADODriver::Start()
719 int res = JackAudioDriver::Start();
723 JackAudioDriver::Stop();
729 int JackFFADODriver::Stop()
732 if (JackAudioDriver::Stop() < 0) {
738 int JackFFADODriver::Read()
749 jack_nframes_t nframes = ffado_driver_wait(driver, -1, &wait_status,
752 if ((wait_status < 0)) {
753 printError(
"wait status < 0! (= %d)", wait_status);
762 NotifyXRun(fBeginDateUst, fDelayedUsecs);
766 if (nframes != fEngineControl->fBufferSize)
767 jack_log(
"JackFFADODriver::Read warning nframes = %ld", nframes);
770 JackDriver::CycleIncTime();
773 return ffado_driver_read((
ffado_driver_t *)fDriver, fEngineControl->fBufferSize);
776 int JackFFADODriver::Write()
779 int res = ffado_driver_write((
ffado_driver_t *)fDriver, fEngineControl->fBufferSize);
787 memset (driver, 0,
sizeof (*driver));
793 driver->null_cycle = 0;
802 memset (driver, 0,
sizeof (*driver));
812 driver->nt_bufsize = 0;
813 driver->nt_start = 0;
815 driver->nt_attach = 0;
816 driver->nt_detach = 0;
817 driver->nt_run_cycle = 0;
829 driver_get_descriptor () {
834 desc = jack_driver_descriptor_construct(
"firewire", JackDriverMaster,
"Linux FFADO API based audio backend", &filler);
836 strcpy(value.str,
"hw:0");
837 jack_driver_descriptor_add_parameter(
842 JackDriverParamString,
845 "The FireWire device to use.",
846 "The FireWire device to use. Please consult the FFADO documentation for more info.");
849 jack_driver_descriptor_add_parameter(desc, &filler,
"period",
'p', JackDriverParamUInt, &value, NULL,
"Frames per period", NULL);
852 jack_driver_descriptor_add_parameter(desc, &filler,
"nperiods",
'n', JackDriverParamUInt, &value, NULL,
"Number of periods of playback latency", NULL);
855 jack_driver_descriptor_add_parameter(desc, &filler,
"rate",
'r', JackDriverParamUInt, &value, NULL,
"Sample rate", NULL);
858 jack_driver_descriptor_add_parameter(desc, &filler,
"capture",
'C', JackDriverParamBool, &value, NULL,
"Provide capture ports.", NULL);
859 jack_driver_descriptor_add_parameter(desc, &filler,
"playback",
'P', JackDriverParamBool, &value, NULL,
"Provide playback ports.", NULL);
862 jack_driver_descriptor_add_parameter(desc, &filler,
"duplex",
'D', JackDriverParamBool, &value, NULL,
"Provide both capture and playback ports.", NULL);
865 jack_driver_descriptor_add_parameter(desc, &filler,
"input-latency",
'I', JackDriverParamUInt, &value, NULL,
"Extra input latency (frames)", NULL);
866 jack_driver_descriptor_add_parameter(desc, &filler,
"output-latency",
'O', JackDriverParamUInt, &value, NULL,
"Extra output latency (frames)", NULL);
869 jack_driver_descriptor_add_parameter(desc, &filler,
"inchannels",
'i', JackDriverParamUInt, &value, NULL,
"Number of input channels to provide (note: currently ignored)", NULL);
870 jack_driver_descriptor_add_parameter(desc, &filler,
"outchannels",
'o', JackDriverParamUInt, &value, NULL,
"Number of output channels to provide (note: currently ignored)", NULL);
873 jack_driver_descriptor_add_parameter(desc, &filler,
"verbose",
'v', JackDriverParamUInt, &value, NULL,
"libffado verbose level", NULL);
876 jack_driver_descriptor_add_parameter(desc, &filler,
"snoop",
'X', JackDriverParamBool, &value, NULL,
"Snoop firewire traffic", NULL);
887 char *device_name=(
char*)
"hw:0";
889 cmlparams.period_size_set = 0;
890 cmlparams.sample_rate_set = 0;
891 cmlparams.buffer_size_set = 0;
894 cmlparams.period_size = 1024;
895 cmlparams.sample_rate = 48000;
896 cmlparams.buffer_size = 3;
897 cmlparams.playback_ports = 0;
898 cmlparams.capture_ports = 0;
899 cmlparams.playback_frame_latency = 0;
900 cmlparams.capture_frame_latency = 0;
902 cmlparams.verbose_level = 0;
904 cmlparams.slave_mode = 0;
905 cmlparams.snoop_mode = 0;
906 cmlparams.device_info = NULL;
908 for (node = params; node; node = jack_slist_next (node)) {
911 switch (param->character) {
913 device_name =
const_cast<char*
>(param->value.str);
916 cmlparams.period_size = param->value.ui;
917 cmlparams.period_size_set = 1;
920 cmlparams.buffer_size = param->value.ui;
921 cmlparams.buffer_size_set = 1;
924 cmlparams.sample_rate = param->value.ui;
925 cmlparams.sample_rate_set = 1;
928 cmlparams.capture_ports = param->value.ui;
931 cmlparams.playback_ports = param->value.ui;
934 cmlparams.capture_frame_latency = param->value.ui;
937 cmlparams.playback_frame_latency = param->value.ui;
940 cmlparams.slave_mode = param->value.ui;
943 cmlparams.snoop_mode = param->value.i;
946 cmlparams.verbose_level = param->value.ui;
951 if (!cmlparams.playback_ports && !cmlparams.capture_ports) {
952 cmlparams.playback_ports = 1;
953 cmlparams.capture_ports = 1;
957 cmlparams.device_info = device_name;
962 if (ffado_driver->Open(&cmlparams) == 0) {
963 return threaded_driver;
965 delete threaded_driver;
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,...)