diff --git a/linux/firewire/JackFFADODriver.cpp b/linux/firewire/JackFFADODriver.cpp new file mode 100644 index 00000000..564431b2 --- /dev/null +++ b/linux/firewire/JackFFADODriver.cpp @@ -0,0 +1,1165 @@ +/* +Copyright (C) 2001 Paul Davis +Copyright (C) 2004 Grame +Copyright (C) 2007 Pieter Palmers + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +*/ + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "JackFFADODriver.h" +#include "JackEngineControl.h" +#include "JackClientControl.h" +#include "JackPort.h" +#include "JackGraphManager.h" + +namespace Jack +{ + +#define FIREWIRE_REQUIRED_FFADO_API_VERSION 5 + +#define jack_get_microseconds GetMicroSeconds + +#define SAMPLE_MAX_24BIT 8388608.0f +#define SAMPLE_MAX_16BIT 32768.0f + +int +JackFFADODriver::ffado_driver_read (ffado_driver_t * driver, jack_nframes_t nframes) +{ + jack_default_audio_sample_t* buf = NULL; +// channel_t chn; +// JSList *node; +// jack_port_t* port; + + ffado_sample_t nullbuffer[nframes]; + void *addr_of_nullbuffer = (void *)nullbuffer; + + ffado_streaming_stream_type stream_type; + + printEnter(); + + //make sure all buffers have a valid buffer if not connected + for (unsigned int i = 0; i < driver->capture_nchannels; i++) { + stream_type = ffado_streaming_get_capture_stream_type(driver->dev, i); + if (stream_type == ffado_stream_type_audio) { + ffado_streaming_set_capture_stream_buffer(driver->dev, i, (char *)(nullbuffer)); + ffado_streaming_capture_stream_onoff(driver->dev, i, 0); + } else if (stream_type == ffado_stream_type_midi) { + // these should be read/written with the per-stream functions + } else { // empty other buffers without doing something with them + ffado_streaming_set_capture_stream_buffer(driver->dev, i, (char *)(nullbuffer)); + ffado_streaming_capture_stream_onoff(driver->dev, i, 0); + } + } + + for (int i = 0; i < fCaptureChannels; i++) { + stream_type = ffado_streaming_get_capture_stream_type(driver->dev, i); + if (stream_type == ffado_stream_type_audio) { + + if (fGraphManager->GetConnectionsNum(fCapturePortList[i]) > 0) { + buf = (jack_default_audio_sample_t*)fGraphManager->GetBuffer(fCapturePortList[i], nframes); + + if (!buf) { + buf = (jack_default_audio_sample_t *)addr_of_nullbuffer; + } + ffado_streaming_set_capture_stream_buffer(driver->dev, i, (char *)(buf)); + ffado_streaming_capture_stream_onoff(driver->dev, i, 1); + + } + } else if (stream_type == ffado_stream_type_midi) { + // these should be read/written with the per-stream functions + } else { // empty other buffers without doing something with them + ffado_streaming_set_capture_stream_buffer(driver->dev, i, (char *)(nullbuffer)); + ffado_streaming_capture_stream_onoff(driver->dev, i, 0); + } + } + + // now transfer the buffers + ffado_streaming_transfer_capture_buffers(driver->dev); + printExit(); + return 0; +} + +int +JackFFADODriver::ffado_driver_write (ffado_driver_t * driver, jack_nframes_t nframes) +{ + jack_default_audio_sample_t* buf = NULL; + ffado_streaming_stream_type stream_type; + + ffado_sample_t nullbuffer[nframes]; + void *addr_of_nullbuffer = (void*)nullbuffer; + + memset(&nullbuffer, 0, nframes*sizeof(ffado_sample_t)); + + printEnter(); + + driver->process_count++; + + assert(driver->dev); + + // make sure all buffers output silence if not connected + for (unsigned int i = 0; i < driver->playback_nchannels; i++) { + stream_type = ffado_streaming_get_playback_stream_type(driver->dev, i); + if (stream_type == ffado_stream_type_audio) { + ffado_streaming_set_playback_stream_buffer(driver->dev, i, (char *)(nullbuffer)); + ffado_streaming_playback_stream_onoff(driver->dev, i, 0); + } else if (stream_type == ffado_stream_type_midi) { + // these should be read/written with the per-stream functions + } else { // empty other buffers without doing something with them + ffado_streaming_set_playback_stream_buffer(driver->dev, i, (char *)(nullbuffer)); + ffado_streaming_playback_stream_onoff(driver->dev, i, 0); + } + } + + for (int i = 0; i < fPlaybackChannels; i++) { + stream_type = ffado_streaming_get_playback_stream_type(driver->dev, i); + if (stream_type == ffado_stream_type_audio) { + // Ouput ports + if (fGraphManager->GetConnectionsNum(fPlaybackPortList[i]) > 0) { + buf = (jack_default_audio_sample_t*)fGraphManager->GetBuffer(fPlaybackPortList[i], nframes); + + if (!buf) { + buf = (jack_default_audio_sample_t *)addr_of_nullbuffer; + } + + ffado_streaming_set_playback_stream_buffer(driver->dev, i, (char *)(buf)); + ffado_streaming_playback_stream_onoff(driver->dev, i, 1); + } + } + } + + ffado_streaming_transfer_playback_buffers(driver->dev); + printExit(); + return 0; +} + +jack_nframes_t +JackFFADODriver::ffado_driver_wait (ffado_driver_t *driver, int extra_fd, int *status, + float *delayed_usecs) +{ + int nframes; + jack_time_t wait_enter; + jack_time_t wait_ret; + + printEnter(); + + wait_enter = jack_get_microseconds (); + if (wait_enter > driver->wait_next) { + /* + * This processing cycle was delayed past the + * next due interrupt! Do not account this as + * a wakeup delay: + */ + driver->wait_next = 0; + driver->wait_late++; + } +// *status = -2; interrupt +// *status = -3; timeout +// *status = -4; extra FD + + nframes = ffado_streaming_wait(driver->dev); + + wait_ret = jack_get_microseconds (); + + if (driver->wait_next && wait_ret > driver->wait_next) { + *delayed_usecs = wait_ret - driver->wait_next; + } + driver->wait_last = wait_ret; + driver->wait_next = wait_ret + driver->period_usecs; +// driver->engine->transport_cycle_start (driver->engine, wait_ret); + + if (nframes < 0) { + *status = 0; + return 0; + } + + *status = 0; + fLastWaitUst = wait_ret; + + // FIXME: this should do something more usefull + *delayed_usecs = 0; + printExit(); + return nframes - nframes % driver->period_size; +} + +int +JackFFADODriver::ffado_driver_start (ffado_driver_t *driver) +{ + int retval = 0; + +#ifdef FFADO_DRIVER_WITH_MIDI + if (driver->midi_handle) { + if ((retval = ffado_driver_midi_start(driver->midi_handle))) { + printError("Could not start MIDI threads"); + return retval; + } + } +#endif + + if ((retval = ffado_streaming_start(driver->dev))) { + printError("Could not start streaming threads"); +#ifdef FFADO_DRIVER_WITH_MIDI + if (driver->midi_handle) { + ffado_driver_midi_stop(driver->midi_handle); + } +#endif + return retval; + } + + return 0; +} + +int +JackFFADODriver::ffado_driver_stop (ffado_driver_t *driver) +{ + int retval = 0; + +#ifdef FFADO_DRIVER_WITH_MIDI + if (driver->midi_handle) { + if ((retval = ffado_driver_midi_stop(driver->midi_handle))) { + printError("Could not stop MIDI threads"); + return retval; + } + } +#endif + if ((retval = ffado_streaming_stop(driver->dev))) { + printError("Could not stop streaming threads"); + return retval; + } + + return 0; +} + +int +JackFFADODriver::ffado_driver_restart (ffado_driver_t *driver) +{ + if (Stop()) + return -1; + return Start(); +} + +int +JackFFADODriver::SetBufferSize (jack_nframes_t nframes) +{ + printError("Buffer size change requested but not supported!!!"); + + /* + driver->period_size = nframes; + driver->period_usecs = + (jack_time_t) floor ((((float) nframes) / driver->sample_rate) + * 1000000.0f); + */ + + /* tell the engine to change its buffer size */ + //driver->engine->set_buffer_size (driver->engine, nframes); + + return -1; // unsupported +} + +typedef void (*JackDriverFinishFunction) (jack_driver_t *); + +ffado_driver_t * +JackFFADODriver::ffado_driver_new (char *name, + ffado_jack_settings_t *params) +{ + ffado_driver_t *driver; + + assert(params); + + if(ffado_get_api_version() != FIREWIRE_REQUIRED_FFADO_API_VERSION) { + printError("Incompatible libffado version! (%s)", ffado_get_version()); + return NULL; + } + + printMessage("Starting FFADO backend (%s)", ffado_get_version()); + + driver = (ffado_driver_t*)calloc (1, sizeof (ffado_driver_t)); + + /* Setup the jack interfaces */ + jack_driver_nt_init ((jack_driver_nt_t *) driver); + + /* driver->nt_attach = (JackDriverNTAttachFunction) ffado_driver_attach; + driver->nt_detach = (JackDriverNTDetachFunction) ffado_driver_detach; + driver->nt_start = (JackDriverNTStartFunction) ffado_driver_start; + driver->nt_stop = (JackDriverNTStopFunction) ffado_driver_stop; + driver->nt_run_cycle = (JackDriverNTRunCycleFunction) ffado_driver_run_cycle; + driver->null_cycle = (JackDriverNullCycleFunction) ffado_driver_null_cycle; + driver->write = (JackDriverReadFunction) ffado_driver_write; + driver->read = (JackDriverReadFunction) ffado_driver_read; + driver->nt_bufsize = (JackDriverNTBufSizeFunction) ffado_driver_bufsize; + */ + + /* copy command line parameter contents to the driver structure */ + memcpy(&driver->settings, params, sizeof(ffado_jack_settings_t)); + + /* prepare all parameters */ + driver->sample_rate = params->sample_rate; + driver->period_size = params->period_size; + fLastWaitUst = 0; + + driver->period_usecs = + (jack_time_t) floor ((((float) driver->period_size) * 1000000.0f) / driver->sample_rate); + +// driver->client = client; + driver->engine = NULL; + + memset(&driver->device_options, 0, sizeof(driver->device_options)); + driver->device_options.sample_rate = params->sample_rate; + driver->device_options.period_size = params->period_size; + driver->device_options.nb_buffers = params->buffer_size; + driver->device_options.verbose = params->verbose_level; + driver->capture_frame_latency = params->capture_frame_latency; + driver->playback_frame_latency = params->playback_frame_latency; + + debugPrint(DEBUG_LEVEL_STARTUP, " Driver compiled on %s %s", __DATE__, __TIME__); + debugPrint(DEBUG_LEVEL_STARTUP, " Created driver %s", name); + debugPrint(DEBUG_LEVEL_STARTUP, " period_size: %d", driver->device_options.period_size); + debugPrint(DEBUG_LEVEL_STARTUP, " period_usecs: %d", driver->period_usecs); + debugPrint(DEBUG_LEVEL_STARTUP, " sample rate: %d", driver->device_options.sample_rate); + debugPrint(DEBUG_LEVEL_STARTUP, " verbose level: %d", driver->device_options.verbose); + + return (ffado_driver_t *) driver; +} + +void +JackFFADODriver::ffado_driver_delete (ffado_driver_t *driver) +{ + free (driver); +} + +#ifdef FFADO_DRIVER_WITH_MIDI +/* + * MIDI support + */ + +// the thread that will queue the midi events from the seq to the stream buffers + +void * +JackFFADODriver::ffado_driver_midi_queue_thread(void *arg) +{ + ffado_driver_midi_handle_t *m = (ffado_driver_midi_handle_t *)arg; + assert(m); + snd_seq_event_t *ev; + unsigned char work_buffer[MIDI_TRANSMIT_BUFFER_SIZE]; + int bytes_to_send; + int b; + int i; + + printMessage("MIDI queue thread started"); + + while (1) { + // get next event, if one is present + while ((snd_seq_event_input(m->seq_handle, &ev) > 0)) { + // get the port this event is originated from + ffado_midi_port_t *port = NULL; + for (i = 0;i < m->nb_output_ports;i++) { + if (m->output_ports[i]->seq_port_nr == ev->dest.port) { + port = m->output_ports[i]; + break; + } + } + + if (!port) { + printError(" Could not find target port for event: dst=%d src=%d", ev->dest.port, ev->source.port); + + break; + } + + // decode it to the work buffer + if ((bytes_to_send = snd_midi_event_decode ( port->parser, + work_buffer, + MIDI_TRANSMIT_BUFFER_SIZE, + ev)) < 0) { // failed + printError(" Error decoding event for port %d (errcode=%d)", port->seq_port_nr, bytes_to_send); + bytes_to_send = 0; + //return -1; + } + + for (b = 0;b < bytes_to_send;b++) { + ffado_sample_t tmp_event = work_buffer[b]; + if (ffado_streaming_write(m->dev, port->stream_nr, &tmp_event, 1) < 1) { + printError(" Midi send buffer overrun"); + } + } + + } + + // sleep for some time + usleep(MIDI_THREAD_SLEEP_TIME_USECS); + } + return NULL; +} + +// the dequeue thread (maybe we need one thread per stream) +void * +JackFFADODriver::ffado_driver_midi_dequeue_thread (void *arg) +{ + ffado_driver_midi_handle_t *m = (ffado_driver_midi_handle_t *)arg; + + int i; + int s; + int samples_read; + + assert(m); + + while (1) { + // read incoming events + + for (i = 0;i < m->nb_input_ports;i++) { + unsigned int buff[64]; + + ffado_midi_port_t *port = m->input_ports[i]; + + if (!port) { + printError(" something went wrong when setting up the midi input port map (%d)", i); + } + + do { + samples_read = ffado_streaming_read(m->dev, port->stream_nr, buff, 64); + + for (s = 0;s < samples_read;s++) { + unsigned int *byte = (buff + s) ; + snd_seq_event_t ev; + if ((snd_midi_event_encode_byte(port->parser, (*byte) & 0xFF, &ev)) > 0) { + // a midi message is complete, send it out to ALSA + snd_seq_ev_set_subs(&ev); + snd_seq_ev_set_direct(&ev); + snd_seq_ev_set_source(&ev, port->seq_port_nr); + snd_seq_event_output_direct(port->seq_handle, &ev); + } + } + } while (samples_read > 0); + } + + // sleep for some time + usleep(MIDI_THREAD_SLEEP_TIME_USECS); + } + return NULL; +} + +ffado_driver_midi_handle_t * +JackFFADODriver::ffado_driver_midi_init(ffado_driver_t *driver) +{ +// int err; + + char buf[256]; + channel_t chn; + int nchannels; + int i = 0; + + ffado_device_t *dev = driver->dev; + + assert(dev); + + ffado_driver_midi_handle_t *m = calloc(1, sizeof(ffado_driver_midi_handle_t)); + if (!m) { + printError("not enough memory to create midi structure"); + return NULL; + } + + if (snd_seq_open(&m->seq_handle, "default", SND_SEQ_OPEN_DUPLEX, SND_SEQ_NONBLOCK) < 0) { + printError("Error opening ALSA sequencer."); + free(m); + return NULL; + } + + snd_seq_set_client_name(m->seq_handle, "FFADO Jack MIDI"); + + // find out the number of midi in/out ports we need to setup + nchannels = ffado_streaming_get_nb_capture_streams(dev); + + m->nb_input_ports = 0; + + for (chn = 0; chn < nchannels; chn++) { + if (ffado_streaming_get_capture_stream_type(dev, chn) == ffado_stream_type_midi) { + m->nb_input_ports++; + } + } + + m->input_ports = calloc(m->nb_input_ports, sizeof(ffado_midi_port_t *)); + if (!m->input_ports) { + printError("not enough memory to create midi structure"); + free(m); + return NULL; + } + + i = 0; + for (chn = 0; chn < nchannels; chn++) { + if (ffado_streaming_get_capture_stream_type(dev, chn) == ffado_stream_type_midi) { + m->input_ports[i] = calloc(1, sizeof(ffado_midi_port_t)); + if (!m->input_ports[i]) { + // fixme + printError("Could not allocate memory for seq port"); + continue; + } + + ffado_streaming_get_capture_stream_name(dev, chn, buf, sizeof(buf) - 1); + printMessage("Register MIDI IN port %s", buf); + + m->input_ports[i]->seq_port_nr = snd_seq_create_simple_port(m->seq_handle, buf, + SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_SUBS_READ, + SND_SEQ_PORT_TYPE_MIDI_GENERIC); + + if (m->input_ports[i]->seq_port_nr < 0) { + printError("Could not create seq port"); + m->input_ports[i]->stream_nr = -1; + m->input_ports[i]->seq_port_nr = -1; + } else { + m->input_ports[i]->stream_nr = chn; + m->input_ports[i]->seq_handle = m->seq_handle; + if (snd_midi_event_new ( ALSA_SEQ_BUFF_SIZE, &(m->input_ports[i]->parser)) < 0) { + printError("could not init parser for MIDI IN port %d", i); + m->input_ports[i]->stream_nr = -1; + m->input_ports[i]->seq_port_nr = -1; + } + } + + i++; + } + } + + // playback + nchannels = ffado_streaming_get_nb_playback_streams(dev); + + m->nb_output_ports = 0; + + for (chn = 0; chn < nchannels; chn++) { + if (ffado_streaming_get_playback_stream_type(dev, chn) == ffado_stream_type_midi) { + m->nb_output_ports++; + } + } + + m->output_ports = calloc(m->nb_output_ports, sizeof(ffado_midi_port_t *)); + if (!m->output_ports) { + printError("not enough memory to create midi structure"); + for (i = 0; i < m->nb_input_ports; i++) { + free(m->input_ports[i]); + } + free(m->input_ports); + free(m); + return NULL; + } + + i = 0; + for (chn = 0; chn < nchannels; chn++) { + if (ffado_streaming_get_playback_stream_type(dev, chn) == ffado_stream_type_midi) { + m->output_ports[i] = calloc(1, sizeof(ffado_midi_port_t)); + if (!m->output_ports[i]) { + // fixme + printError("Could not allocate memory for seq port"); + continue; + } + + ffado_streaming_get_playback_stream_name(dev, chn, buf, sizeof(buf) - 1); + printMessage("Register MIDI OUT port %s", buf); + + m->output_ports[i]->seq_port_nr = snd_seq_create_simple_port(m->seq_handle, buf, + SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE, + SND_SEQ_PORT_TYPE_MIDI_GENERIC); + + + if (m->output_ports[i]->seq_port_nr < 0) { + printError("Could not create seq port"); + m->output_ports[i]->stream_nr = -1; + m->output_ports[i]->seq_port_nr = -1; + } else { + m->output_ports[i]->stream_nr = chn; + m->output_ports[i]->seq_handle = m->seq_handle; + if (snd_midi_event_new ( ALSA_SEQ_BUFF_SIZE, &(m->output_ports[i]->parser)) < 0) { + printError("could not init parser for MIDI OUT port %d", i); + m->output_ports[i]->stream_nr = -1; + m->output_ports[i]->seq_port_nr = -1; + } + } + + i++; + } + } + + m->dev = dev; + m->driver = driver; + return m; +} + +int +JackFFADODriver::ffado_driver_midi_start (ffado_driver_midi_handle_t *m) +{ + assert(m); + // start threads + + m->queue_thread_realtime = (m->driver->engine->control->real_time ? 1 : 0); + m->queue_thread_priority = + m->driver->engine->control->client_priority + + FFADO_RT_PRIORITY_MIDI_RELATIVE; + + if (m->queue_thread_priority > 98) { + m->queue_thread_priority = 98; + } + if (m->queue_thread_realtime) { + printMessage("MIDI threads running with Realtime scheduling, priority %d", + m->queue_thread_priority); + } else { + printMessage("MIDI threads running without Realtime scheduling"); + } + + if (jack_client_create_thread(NULL, &m->queue_thread, m->queue_thread_priority, m->queue_thread_realtime, ffado_driver_midi_queue_thread, (void *)m)) { + printError(" cannot create midi queueing thread"); + return -1; + } + + if (jack_client_create_thread(NULL, &m->dequeue_thread, m->queue_thread_priority, m->queue_thread_realtime, ffado_driver_midi_dequeue_thread, (void *)m)) { + printError(" cannot create midi dequeueing thread"); + return -1; + } + return 0; +} + +int +JackFFADODriver::ffado_driver_midi_stop (ffado_driver_midi_handle_t *m) +{ + assert(m); + + pthread_cancel (m->queue_thread); + pthread_join (m->queue_thread, NULL); + + pthread_cancel (m->dequeue_thread); + pthread_join (m->dequeue_thread, NULL); + return 0; +} + +void +JackFFADODriver::ffado_driver_midi_finish (ffado_driver_midi_handle_t *m) +{ + assert(m); + + int i; + // TODO: add state info here, if not stopped then stop + + for (i = 0;i < m->nb_input_ports;i++) { + free(m->input_ports[i]); + } + free(m->input_ports); + + for (i = 0;i < m->nb_output_ports;i++) { + free(m->output_ports[i]); + } + free(m->output_ports); + free(m); +} +#endif + +int JackFFADODriver::Attach() +{ + JackPort* port; + int port_index; + unsigned long port_flags; + + char buf[JACK_PORT_NAME_SIZE]; + char portname[JACK_PORT_NAME_SIZE]; + + ffado_driver_t* driver = (ffado_driver_t*)fDriver; + + JackLog("JackFFADODriver::Attach fBufferSize %ld fSampleRate %ld\n", fEngineControl->fBufferSize, fEngineControl->fSampleRate); + + g_verbose = (fEngineControl->fVerbose ? 1 : 0); + + /* packetizer thread options */ + driver->device_options.realtime = (fEngineControl->fRealTime ? 1 : 0); + + driver->device_options.packetizer_priority = fEngineControl->fPriority + + FFADO_RT_PRIORITY_PACKETIZER_RELATIVE; + if (driver->device_options.packetizer_priority > 98) { + driver->device_options.packetizer_priority = 98; + } + + // initialize the thread + driver->dev = ffado_streaming_init(driver->device_info, driver->device_options); + + if (!driver->dev) { + printError("FFADO: Error creating virtual device"); + return -1; + } + +#ifdef FFADO_DRIVER_WITH_MIDI + driver->midi_handle = ffado_driver_midi_init(driver); + if (!driver->midi_handle) { + printError("-----------------------------------------------------------"); + printError("Error creating midi device!"); + printError("FFADO will run without MIDI support."); + printError("Consult the above error messages to solve the problem. "); + printError("-----------------------------------------------------------\n\n"); + } +#endif + + if (driver->device_options.realtime) { + printMessage("Streaming thread running with Realtime scheduling, priority %d", + driver->device_options.packetizer_priority); + } else { + printMessage("Streaming thread running without Realtime scheduling"); + } + + /* ports */ + + // capture + port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal; + + driver->capture_nchannels = ffado_streaming_get_nb_capture_streams(driver->dev); + driver->capture_nchannels_audio = 0; + + for (unsigned int i = 0; i < driver->capture_nchannels; i++) { + + ffado_streaming_get_capture_stream_name(driver->dev, i, portname, sizeof(portname) - 1); + snprintf(buf, sizeof(buf) - 1, "%s:%s", fClientControl->fName, portname); + + if (ffado_streaming_get_capture_stream_type(driver->dev, i) != ffado_stream_type_audio) { + printMessage ("Don't register capture port %s", buf); + } else { + printMessage ("Registering capture port %s", buf); + + if ((port_index = fGraphManager->AllocatePort(fClientControl->fRefNum, buf, + JACK_DEFAULT_AUDIO_TYPE, + (JackPortFlags)port_flags)) == NO_PORT) { + jack_error("driver: cannot register port for %s", buf); + return -1; + } + + ffado_streaming_set_capture_buffer_type(driver->dev, i, ffado_buffer_type_float); + ffado_streaming_capture_stream_onoff(driver->dev, i, 0); + + port = fGraphManager->GetPort(port_index); + port->SetLatency(driver->period_size + driver->capture_frame_latency); + fCapturePortList[i] = port_index; + JackLog("JackFFADODriver::Attach fCapturePortList[i] %ld \n", port_index); + driver->capture_nchannels_audio++; + } + } + + // playback + port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal; + + driver->playback_nchannels = ffado_streaming_get_nb_playback_streams(driver->dev); + driver->playback_nchannels_audio = 0; + + for (unsigned int i = 0; i < driver->playback_nchannels; i++) { + + ffado_streaming_get_playback_stream_name(driver->dev, i, portname, sizeof(portname) - 1); + snprintf(buf, sizeof(buf) - 1, "%s:%s", fClientControl->fName, portname); + + if (ffado_streaming_get_playback_stream_type(driver->dev, i) != ffado_stream_type_audio) { + printMessage ("Don't register playback port %s", buf); + } else { + printMessage ("Registering playback port %s", buf); + if ((port_index = fGraphManager->AllocatePort(fClientControl->fRefNum, buf, + JACK_DEFAULT_AUDIO_TYPE, + (JackPortFlags)port_flags)) == NO_PORT) { + jack_error("driver: cannot register port for %s", buf); + return -1; + } + + ffado_streaming_set_playback_buffer_type(driver->dev, i, ffado_buffer_type_float); + ffado_streaming_playback_stream_onoff(driver->dev, i, 0); + + port = fGraphManager->GetPort(port_index); + port->SetLatency((driver->period_size * (driver->device_options.nb_buffers - 1)) + driver->playback_frame_latency); + fPlaybackPortList[i] = port_index; + JackLog("JackFFADODriver::Attach fPlaybackPortList[i] %ld \n", port_index); + driver->playback_nchannels_audio++; + } + } + + fCaptureChannels = driver->capture_nchannels_audio; + fPlaybackChannels = driver->playback_nchannels_audio; + + assert(fCaptureChannels < PORT_NUM); + assert(fPlaybackChannels < PORT_NUM); + + if(ffado_streaming_prepare(driver->dev)) { + printError("Could not prepare streaming device!"); + return -1; + } + + // this makes no sense... + assert(fCaptureChannels + fPlaybackChannels > 0); + return 0; +} + +int JackFFADODriver::Detach() +{ + ffado_driver_t* driver = (ffado_driver_t*)fDriver; + JackLog("JackFFADODriver::Detach\n"); + + // finish the libfreebob streaming + ffado_streaming_finish(driver->dev); + driver->dev = NULL; + +#ifdef FFADO_DRIVER_WITH_MIDI + if (driver->midi_handle) { + ffado_driver_midi_finish(driver->midi_handle); + } + driver->midi_handle = NULL; +#endif + + return JackAudioDriver::Detach(); // Generic JackAudioDriver Detach +} + +int JackFFADODriver::Open(ffado_jack_settings_t *params) +{ + // Generic JackAudioDriver Open + if (JackAudioDriver::Open( + params->period_size, params->sample_rate, + params->playback_ports, params->playback_ports, + 0, 0, 0, "", "", + params->capture_frame_latency, params->playback_frame_latency) != 0) { + return -1; + } + + fDriver = (jack_driver_t *)ffado_driver_new ("ffado_pcm", params); + + if (fDriver) { + // FFADO driver may have changed the in/out values + fCaptureChannels = ((ffado_driver_t *)fDriver)->capture_nchannels_audio; + fPlaybackChannels = ((ffado_driver_t *)fDriver)->playback_nchannels_audio; + return 0; + } else { + return -1; + } +} + +int JackFFADODriver::Close() +{ + JackAudioDriver::Close(); + ffado_driver_delete((ffado_driver_t*)fDriver); + return 0; +} + +int JackFFADODriver::Start() +{ + return ffado_driver_start((ffado_driver_t *)fDriver); +} + +int JackFFADODriver::Stop() +{ + return ffado_driver_stop((ffado_driver_t *)fDriver); +} + +int JackFFADODriver::Read() +{ + printEnter(); + + /* Taken from ffado_driver_run_cycle */ + ffado_driver_t* driver = (ffado_driver_t*)fDriver; + int wait_status = 0; + float delayed_usecs = 0.0; + + jack_nframes_t nframes = ffado_driver_wait (driver, -1, &wait_status, + &delayed_usecs); + + if ((wait_status < 0)) { + printError( "wait status < 0! (= %d)", wait_status); + return -1; + } + + if (nframes == 0) { + + /* we detected an xrun and restarted: notify + * clients about the delay. + */ + //engine->delay (engine, delayed_usecs); + JackLog("FFADO XRun \n"); + //NotifyXRun(jack_get_microseconds()); + NotifyXRun(fLastWaitUst); + //return 0; + return -1; + } + + //fLastWaitUst = GetMicroSeconds(); // Take callback date here + if (nframes != fEngineControl->fBufferSize) + JackLog("JackFFADODriver::Read nframes = %ld\n", nframes); + + //return engine->run_cycle (engine, nframes, delayed_usecs); + fDelayedUst = (jack_time_t)delayed_usecs; + printExit(); + return ffado_driver_read((ffado_driver_t *)fDriver, fEngineControl->fBufferSize); +} + +int JackFFADODriver::Write() +{ + printEnter(); + int res = ffado_driver_write((ffado_driver_t *)fDriver, fEngineControl->fBufferSize); + printExit(); + return res; +} + +void +JackFFADODriver::jack_driver_init (jack_driver_t *driver) +{ + memset (driver, 0, sizeof (*driver)); + + driver->attach = 0; + driver->detach = 0; + driver->write = 0; + driver->read = 0; + driver->null_cycle = 0; + driver->bufsize = 0; + driver->start = 0; + driver->stop = 0; +} + +void +JackFFADODriver::jack_driver_nt_init (jack_driver_nt_t * driver) +{ + memset (driver, 0, sizeof (*driver)); + + jack_driver_init ((jack_driver_t *) driver); + + driver->attach = 0; + driver->detach = 0; + driver->bufsize = 0; + driver->stop = 0; + driver->start = 0; + + driver->nt_bufsize = 0; + driver->nt_start = 0; + driver->nt_stop = 0; + driver->nt_attach = 0; + driver->nt_detach = 0; + driver->nt_run_cycle = 0; +} + +} // end of namespace + + +#ifdef __cplusplus +extern "C" +{ +#endif + + const jack_driver_desc_t * + driver_get_descriptor () { + jack_driver_desc_t * desc; + jack_driver_param_desc_t * params; + unsigned int i; + + desc = (jack_driver_desc_t *)calloc (1, sizeof (jack_driver_desc_t)); + + strcpy (desc->name, "firewire"); + desc->nparams = 12; + + params = (jack_driver_param_desc_t *)calloc (desc->nparams, sizeof (jack_driver_param_desc_t)); + desc->params = params; + + i = 0; + strcpy (params[i].name, "device"); + params[i].character = 'd'; + params[i].type = JackDriverParamString; + strcpy (params[i].value.str, "hw:0"); + strcpy (params[i].short_desc, "The FireWire device to use. Format is: 'hw:port[,node]'."); + strcpy (params[i].long_desc, params[i].short_desc); + + i++; + strcpy (params[i].name, "period"); + params[i].character = 'p'; + params[i].type = JackDriverParamUInt; + params[i].value.ui = 1024; + strcpy (params[i].short_desc, "Frames per period"); + strcpy (params[i].long_desc, params[i].short_desc); + + i++; + strcpy (params[i].name, "nperiods"); + params[i].character = 'n'; + params[i].type = JackDriverParamUInt; + params[i].value.ui = 3; + strcpy (params[i].short_desc, "Number of periods of playback latency"); + strcpy (params[i].long_desc, params[i].short_desc); + + i++; + strcpy (params[i].name, "rate"); + params[i].character = 'r'; + params[i].type = JackDriverParamUInt; + params[i].value.ui = 48000U; + strcpy (params[i].short_desc, "Sample rate"); + strcpy (params[i].long_desc, params[i].short_desc); + + i++; + strcpy (params[i].name, "capture"); + params[i].character = 'C'; + params[i].type = JackDriverParamBool; + params[i].value.i = 0; + strcpy (params[i].short_desc, "Provide capture ports."); + strcpy (params[i].long_desc, params[i].short_desc); + + i++; + strcpy (params[i].name, "playback"); + params[i].character = 'P'; + params[i].type = JackDriverParamBool; + params[i].value.i = 0; + strcpy (params[i].short_desc, "Provide playback ports."); + strcpy (params[i].long_desc, params[i].short_desc); + + i++; + strcpy (params[i].name, "duplex"); + params[i].character = 'D'; + params[i].type = JackDriverParamBool; + params[i].value.i = 1; + strcpy (params[i].short_desc, "Provide both capture and playback ports."); + strcpy (params[i].long_desc, params[i].short_desc); + + i++; + strcpy (params[i].name, "input-latency"); + params[i].character = 'I'; + params[i].type = JackDriverParamUInt; + params[i].value.ui = 0; + strcpy (params[i].short_desc, "Extra input latency (frames)"); + strcpy (params[i].long_desc, params[i].short_desc); + + i++; + strcpy (params[i].name, "output-latency"); + params[i].character = 'O'; + params[i].type = JackDriverParamUInt; + params[i].value.ui = 0; + strcpy (params[i].short_desc, "Extra output latency (frames)"); + strcpy (params[i].long_desc, params[i].short_desc); + + i++; + strcpy (params[i].name, "inchannels"); + params[i].character = 'i'; + params[i].type = JackDriverParamUInt; + params[i].value.ui = 0; + strcpy (params[i].short_desc, "Number of input channels to provide (note: currently ignored)"); + strcpy (params[i].long_desc, params[i].short_desc); + + i++; + strcpy (params[i].name, "outchannels"); + params[i].character = 'o'; + params[i].type = JackDriverParamUInt; + params[i].value.ui = 0; + strcpy (params[i].short_desc, "Number of output channels to provide (note: currently ignored)"); + strcpy (params[i].long_desc, params[i].short_desc); + + i++; + strcpy (params[i].name, "verbose"); + params[i].character = 'v'; + params[i].type = JackDriverParamUInt; + params[i].value.ui = 3; + strcpy (params[i].short_desc, "libffado verbose level"); + strcpy (params[i].long_desc, params[i].short_desc); + + return desc; + } + + Jack::JackDriverClientInterface* driver_initialize(Jack::JackEngine* engine, Jack::JackSynchro** table, const JSList* params) { + const JSList * node; + const jack_driver_param_t * param; + + ffado_jack_settings_t cmlparams; + + char *device_name = "hw:0"; + + cmlparams.period_size_set = 0; + cmlparams.sample_rate_set = 0; + cmlparams.buffer_size_set = 0; + + /* default values */ + cmlparams.period_size = 1024; + cmlparams.sample_rate = 48000; + cmlparams.buffer_size = 3; + cmlparams.playback_ports = 0; + cmlparams.capture_ports = 0; + cmlparams.playback_frame_latency = 0; + cmlparams.capture_frame_latency = 0; + + for (node = params; node; node = jack_slist_next (node)) { + param = (jack_driver_param_t *) node->data; + + switch (param->character) { + case 'd': + device_name = strdup (param->value.str); + break; + case 'p': + cmlparams.period_size = param->value.ui; + cmlparams.period_size_set = 1; + break; + case 'n': + cmlparams.buffer_size = param->value.ui; + cmlparams.buffer_size_set = 1; + break; + case 'r': + cmlparams.sample_rate = param->value.ui; + cmlparams.sample_rate_set = 1; + break; + case 'C': + cmlparams.capture_ports = 1; + break; + case 'P': + cmlparams.playback_ports = 1; + break; + case 'D': + cmlparams.capture_ports = 1; + cmlparams.playback_ports = 1; + break; + case 'I': + cmlparams.capture_frame_latency = param->value.ui; + break; + case 'O': + cmlparams.playback_frame_latency = param->value.ui; + break; + // ignore these for now + case 'i': + break; + case 'o': + break; + case 'v': + cmlparams.verbose_level = param->value.ui; + } + } + + /* duplex is the default */ + if (!cmlparams.playback_ports && !cmlparams.capture_ports) { + cmlparams.playback_ports = TRUE; + cmlparams.capture_ports = TRUE; + } + + Jack::JackFFADODriver* ffado_driver = new Jack::JackFFADODriver("firewire_pcm", engine, table); + Jack::JackDriverClientInterface* threaded_driver = new Jack::JackThreadedDriver(ffado_driver); + // Special open for FFADO driver... + if (ffado_driver->Open(&cmlparams) == 0) { + return threaded_driver; + } else { + delete threaded_driver; // Delete the decorated driver + return NULL; + } + } + +#ifdef __cplusplus +} +#endif + + diff --git a/linux/firewire/JackFFADODriver.h b/linux/firewire/JackFFADODriver.h new file mode 100644 index 00000000..75008697 --- /dev/null +++ b/linux/firewire/JackFFADODriver.h @@ -0,0 +1,95 @@ +/* +Copyright (C) 2001 Paul Davis +Copyright (C) 2004 Grame +Copyright (C) 2007 Pieter Palmers + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +*/ + +#ifndef __JackFFADODriver__ +#define __JackFFADODriver__ + +#include "JackAudioDriver.h" +#include "JackThreadedDriver.h" +#include "JackTime.h" + +#include "ffado_driver.h" + +namespace Jack +{ + +/*! +\brief The FFADO driver. +*/ + +class JackFFADODriver : public JackAudioDriver +{ + + private: + + // enable verbose messages + int g_verbose; + + jack_driver_t* fDriver; + jack_time_t fDelayedUst; + int ffado_driver_attach (ffado_driver_t *driver); + int ffado_driver_detach (ffado_driver_t *driver); + int ffado_driver_read (ffado_driver_t * driver, jack_nframes_t nframes); + int ffado_driver_write (ffado_driver_t * driver, jack_nframes_t nframes); + jack_nframes_t ffado_driver_wait (ffado_driver_t *driver, + int extra_fd, int *status, + float *delayed_usecs); + int ffado_driver_start (ffado_driver_t *driver); + int ffado_driver_stop (ffado_driver_t *driver); + int ffado_driver_restart (ffado_driver_t *driver); + ffado_driver_t *ffado_driver_new (char *name, ffado_jack_settings_t *params); + void ffado_driver_delete (ffado_driver_t *driver); + +#ifdef FREEBOB_DRIVER_WITH_MIDI + ffado_driver_midi_handle_t *ffado_driver_midi_init(ffado_driver_t *driver); + void ffado_driver_midi_finish (ffado_driver_midi_handle_t *m); + int ffado_driver_midi_start (ffado_driver_midi_handle_t *m); + int ffado_driver_midi_stop (ffado_driver_midi_handle_t *m); +#endif + + void jack_driver_init (jack_driver_t *driver); + void jack_driver_nt_init (jack_driver_nt_t * driver); + + public: + + JackFFADODriver(const char* name, JackEngine* engine, JackSynchro** table): JackAudioDriver(name, engine, table) + {} + virtual ~JackFFADODriver() + {} + + int Open(ffado_jack_settings_t *cmlparams); + + int Close(); + int Attach(); + int Detach(); + + int Start(); + int Stop(); + + int Read(); + int Write(); + + int SetBufferSize(jack_nframes_t nframes); +}; + +} // end of namespace + +#endif diff --git a/linux/firewire/ffado_driver.h b/linux/firewire/ffado_driver.h new file mode 100644 index 00000000..2b61bb8f --- /dev/null +++ b/linux/firewire/ffado_driver.h @@ -0,0 +1,240 @@ +/* ffado_driver.h + * + * FreeBob Backend for Jack + * FreeBob = Firewire (pro-)audio for linux + * + * adapted for jackmp + * + * http://freebob.sf.net + * http://jackit.sf.net + * + * Copyright (C) 2005,2006,2007 Pieter Palmers + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +/* + * Main Jack driver entry routines + * + */ + +#ifndef __JACK_FFADO_DRIVER_H__ +#define __JACK_FFADO_DRIVER_H__ + +// #define FFADO_DRIVER_WITH_MIDI +// #define DEBUG_ENABLED + +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include + +#ifdef FFADO_DRIVER_WITH_MIDI +#include +#include +#endif + +// debug print control flags +#define DEBUG_LEVEL_BUFFERS (1<<0) +#define DEBUG_LEVEL_HANDLERS (1<<1) +#define DEBUG_LEVEL_XRUN_RECOVERY (1<<2) +#define DEBUG_LEVEL_WAIT (1<<3) + +#define DEBUG_LEVEL_RUN_CYCLE (1<<8) + +#define DEBUG_LEVEL_PACKETCOUNTER (1<<16) +#define DEBUG_LEVEL_STARTUP (1<<17) +#define DEBUG_LEVEL_THREADS (1<<18) + +#ifdef DEBUG_ENABLED + +// default debug level +#define DEBUG_LEVEL ( DEBUG_LEVEL_RUN_CYCLE | \ + (DEBUG_LEVEL_XRUN_RECOVERY)| DEBUG_LEVEL_STARTUP | DEBUG_LEVEL_WAIT | DEBUG_LEVEL_PACKETCOUNTER) + +#warning Building debug build! + +#define printMessage(format, args...) jack_error( "FFADO MSG: %s:%d (%s): " format, __FILE__, __LINE__, __FUNCTION__, ##args ) +#define printError(format, args...) jack_error( "FFADO ERR: %s:%d (%s): " format, __FILE__, __LINE__, __FUNCTION__, ##args ) + +/* #define printEnter() jack_error( "FBDRV ENTERS: %s (%s)", __FUNCTION__, __FILE__) + #define printExit() jack_error( "FBDRV EXITS: %s (%s)", __FUNCTION__, __FILE__)*/ +#define printEnter() +#define printExit() + +#define debugError(format, args...) jack_error( "FFADO ERR: %s:%d (%s): " format, __FILE__, __LINE__, __FUNCTION__, ##args ) +#define debugPrint(Level, format, args...) if(DEBUG_LEVEL & (Level)) jack_error("DEBUG %s:%d (%s) :" format, __FILE__, __LINE__, __FUNCTION__, ##args ); +#define debugPrintShort(Level, format, args...) if(DEBUG_LEVEL & (Level)) jack_error( format,##args ); +#define debugPrintWithTimeStamp(Level, format, args...) if(DEBUG_LEVEL & (Level)) jack_error( "%16lu: "format, debugGetCurrentUTime(),##args ); +#define SEGFAULT int *test=NULL; *test=1; +#else +#define DEBUG_LEVEL + +#define printMessage(format, args...) if(g_verbose) \ + jack_error("FFADO MSG: " format, ##args ) +#define printError(format, args...) jack_error("FFADO ERR: " format, ##args ) + +#define printEnter() +#define printExit() + +#define debugError(format, args...) +#define debugPrint(Level, format, args...) +#define debugPrintShort(Level, format, args...) +#define debugPrintWithTimeStamp(Level, format, args...) +#endif + +// thread priority setup +#define FFADO_RT_PRIORITY_PACKETIZER_RELATIVE 5 + +#ifdef FFADO_DRIVER_WITH_MIDI + +#define ALSA_SEQ_BUFF_SIZE 1024 +#define MIDI_TRANSMIT_BUFFER_SIZE 1024 +#define MIDI_THREAD_SLEEP_TIME_USECS 100 +// midi priority should be higher than the audio priority in order to +// make sure events are not only delivered on period boundarys +// but I think it should be smaller than the packetizer thread in order not +// to lose any packets +#define FFADO_RT_PRIORITY_MIDI_RELATIVE 4 + +#endif + +typedef struct _ffado_driver ffado_driver_t; + +/* + * Jack Driver command line parameters + */ + +typedef struct _ffado_jack_settings ffado_jack_settings_t; +struct _ffado_jack_settings +{ + int period_size_set; + jack_nframes_t period_size; + + int sample_rate_set; + int sample_rate; + + int buffer_size_set; + jack_nframes_t buffer_size; + + int playback_ports; + int capture_ports; + + int verbose_level; + + jack_nframes_t capture_frame_latency; + jack_nframes_t playback_frame_latency; + + ffado_handle_t fb_handle; +}; + +#ifdef FFADO_DRIVER_WITH_MIDI + +typedef struct +{ + int stream_nr; + int seq_port_nr; + snd_midi_event_t *parser; + snd_seq_t *seq_handle; +} +ffado_midi_port_t; + +typedef struct _ffado_driver_midi_handle +{ + ffado_device_t *dev; + ffado_driver_t *driver; + + snd_seq_t *seq_handle; + + pthread_t queue_thread; + pthread_t dequeue_thread; + int queue_thread_realtime; + int queue_thread_priority; + + int nb_input_ports; + int nb_output_ports; + + ffado_midi_port_t **input_ports; + ffado_midi_port_t **output_ports; + + ffado_midi_port_t **input_stream_port_map; + int *output_port_stream_map; +} +ffado_driver_midi_handle_t; + +#endif +/* + * JACK driver structure + */ + +struct _ffado_driver +{ + JACK_DRIVER_NT_DECL + + jack_nframes_t sample_rate; + jack_nframes_t period_size; + unsigned long wait_time; + + jack_time_t wait_last; + jack_time_t wait_next; + int wait_late; + + jack_client_t *client; + + int xrun_detected; + int xrun_count; + + int process_count; + + /* settings from the command line */ + ffado_jack_settings_t settings; + + /* the freebob virtual device */ + ffado_device_t *dev; + + JSList *capture_ports; + JSList *playback_ports; + JSList *monitor_ports; + unsigned long playback_nchannels; + unsigned long capture_nchannels; + unsigned long playback_nchannels_audio; + unsigned long capture_nchannels_audio; + + jack_nframes_t playback_frame_latency; + jack_nframes_t capture_frame_latency; + + ffado_device_info_t device_info; + ffado_options_t device_options; + +#ifdef FFADO_DRIVER_WITH_MIDI + ffado_driver_midi_handle_t *midi_handle; +#endif +}; + +#endif /* __JACK_FFADO_DRIVER_H__ */ + +