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;