static int oss_driver_detach (oss_driver_t *driver, jack_engine_t *engine)
{
JSList *node;
if (driver->engine == NULL)
return -1;
/*jack_deactivate(driver->client);*/ /* ? */
node = driver->capture_ports;
while (node != NULL)
{
jack_port_unregister(driver->client,
((jack_port_t *) node->data));
node = jack_slist_next(node);
}
jack_slist_free(driver->capture_ports);
driver->capture_ports = NULL;
node = driver->playback_ports;
while (node != NULL)
{
jack_port_unregister(driver->client,
((jack_port_t *) node->data));
node = jack_slist_next(node);
}
jack_slist_free(driver->playback_ports);
driver->playback_ports = NULL;
driver->engine = NULL;
return 0;
}
static int
coreaudio_driver_detach (coreaudio_driver_t *driver, jack_engine_t *engine)
{
JSList *node;
if (driver->engine == 0) {
return -1;
}
for (node = driver->capture_ports; node; node = jack_slist_next (node)) {
jack_port_unregister (driver->client, ((jack_port_t *) node->data));
}
jack_slist_free (driver->capture_ports);
driver->capture_ports = 0;
for (node = driver->playback_ports; node; node = jack_slist_next (node)) {
jack_port_unregister (driver->client, ((jack_port_t *) node->data));
}
jack_slist_free (driver->playback_ports);
driver->playback_ports = 0;
driver->engine = 0;
return 0;
}
static int
dummy_driver_detach (dummy_driver_t *driver)
{
JSList * node;
if (driver->engine == 0)
return 0;
for (node = driver->capture_ports; node; node = jack_slist_next (node))
jack_port_unregister (driver->client,
((jack_port_t *) node->data));
jack_slist_free (driver->capture_ports);
driver->capture_ports = NULL;
for (node = driver->playback_ports; node; node = jack_slist_next (node))
jack_port_unregister (driver->client,
((jack_port_t *) node->data));
jack_slist_free (driver->playback_ports);
driver->playback_ports = NULL;
return 0;
}
static void
jack_audio_port_mixdown (jack_port_t *port, jack_nframes_t nframes)
{
JSList *node;
jack_port_t *input;
#ifndef ARCH_X86
jack_nframes_t n;
jack_default_audio_sample_t *dst, *src;
#endif
jack_default_audio_sample_t *buffer;
/* by the time we've called this, we've already established
the existence of more than one connection to this input
port and allocated a mix_buffer.
*/
/* no need to take connection lock, since this is called
from the process() callback, and the jack server
ensures that no changes to connections happen
during this time.
*/
node = port->connections;
input = (jack_port_t*)node->data;
buffer = port->mix_buffer;
#ifndef USE_DYNSIMD
memcpy (buffer, jack_output_port_buffer (input),
sizeof(jack_default_audio_sample_t) * nframes);
#else /* USE_DYNSIMD */
opt_copy (buffer, jack_output_port_buffer (input), nframes);
#endif /* USE_DYNSIMD */
for (node = jack_slist_next (node); node;
node = jack_slist_next (node)) {
input = (jack_port_t*)node->data;
#ifndef USE_DYNSIMD
n = nframes;
dst = buffer;
src = jack_output_port_buffer (input);
while (n--)
*dst++ += *src++;
#else /* USE_DYNSIMD */
opt_mix (buffer, jack_output_port_buffer (input), nframes);
#endif /* USE_DYNSIMD */
}
}
int
jack_port_connected_to (const jack_port_t *port, const char *portname)
{
JSList *node;
int ret = FALSE;
/* XXX this really requires a cross-process lock
so that ports/connections cannot go away
while we are checking for them. that's hard,
and has a non-trivial performance impact
for jackd.
*/
pthread_mutex_lock (&((jack_port_t *) port)->connection_lock);
for (node = port->connections; node; node = jack_slist_next (node)) {
jack_port_t *other_port = (jack_port_t *) node->data;
if (jack_port_name_equals (other_port->shared, portname)) {
ret = TRUE;
break;
}
}
pthread_mutex_unlock (&((jack_port_t *) port)->connection_lock);
return ret;
}
SERVER_EXPORT Jack::JackDriverClientInterface* driver_initialize(Jack::JackLockedEngine* engine, Jack::JackSynchro* table, const JSList* params)
{
const JSList * node;
const jack_driver_param_t * param;
int channels = 2;
for (node = params; node; node = jack_slist_next (node)) {
param = (const jack_driver_param_t *) node->data;
switch (param->character) {
case 'c':
channels = param->value.ui;
break;
}
}
Jack::JackDriverClientInterface* driver = new Jack::JackLoopbackDriver(engine, table);
if (driver->Open(1, 1, channels, channels, false, "loopback", "loopback", 0, 0) == 0) {
return driver;
} else {
delete driver;
return NULL;
}
}
static int
portaudio_driver_write (portaudio_driver_t *driver, jack_nframes_t nframes)
{
jack_default_audio_sample_t *buf;
channel_t chn;
jack_port_t *port;
JSList *node;
int i,bytes = nframes*sizeof(float);
/* Clear in case of nothing is connected */
memset(driver->outPortAudio, 0, driver->playback_nchannels*bytes);
for (chn = 0, node = driver->playback_ports; node; node = jack_slist_next (node), chn++) {
port = (jack_port_t *)node->data;
if (jack_port_connected (port) && (driver->outPortAudio != NULL)) {
int channels = driver->playback_nchannels;
float* out = driver->outPortAudio;
buf = jack_port_get_buffer (port, nframes);
for (i = 0; i< nframes; i++) out[channels*i+chn] = buf[i];
}
}
return 0;
}
static int
portaudio_driver_read (portaudio_driver_t *driver, jack_nframes_t nframes)
{
jack_default_audio_sample_t *buf;
channel_t chn;
jack_port_t *port;
JSList *node;
int i;
for (chn = 0, node = driver->capture_ports; node; node = jack_slist_next (node), chn++) {
port = (jack_port_t *)node->data;
if (jack_port_connected (port) && (driver->inPortAudio != NULL)) {
int channels = driver->capture_nchannels;
float* in = driver->inPortAudio;
buf = jack_port_get_buffer (port, nframes);
for (i = 0; i< nframes; i++) buf[i] = in[channels*i+chn];
}
}
driver->engine->transport_cycle_start (driver->engine,
driver->engine->get_microseconds ());
return 0;
}
static int
coreaudio_driver_write (coreaudio_driver_t *driver, jack_nframes_t nframes)
{
jack_default_audio_sample_t *buf;
channel_t chn;
jack_port_t *port;
JSList *node;
for (chn = 0, node = driver->playback_ports; node; node = jack_slist_next (node), chn++) {
port = (jack_port_t *)node->data;
if (driver->outcoreaudio[chn] != NULL) {
float *out = driver->outcoreaudio[chn];
if (jack_port_connected (port)) {
buf = jack_port_get_buffer (port, nframes);
memcpy(out,buf,sizeof(float)*nframes);
} else {
memset(out,0,sizeof(float)*nframes);
}
}
}
return 0;
}
jack_port_t *
jack_port_by_name_int (jack_client_t *client, const char *port_name, int* free)
{
JSList *node;
for (node = client->ports; node; node = jack_slist_next (node)) {
if (jack_port_name_equals(((jack_port_t *) node->data)->shared, port_name)) {
*free = FALSE;
return (jack_port_t *) node->data;
}
}
unsigned long i, limit;
jack_port_shared_t *port;
limit = client->engine->port_max;
port = &client->engine->ports[0];
for (i = 0; i < limit; i++) {
if (port[i].in_use && jack_port_name_equals (&port[i], port_name)) {
*free = TRUE;
return jack_port_new (client, port[i].id,
client->engine);
}
}
return NULL;
}
JackAlsaAdapter::JackAlsaAdapter ( jack_nframes_t buffer_size, jack_nframes_t sample_rate, const JSList* params ) :
JackAudioAdapterInterface ( buffer_size, sample_rate ),
fThread ( this ),
fAudioInterface ( buffer_size, sample_rate )
{
const JSList* node;
const jack_driver_param_t* param;
fCaptureChannels = 2;
fPlaybackChannels = 2;
fAudioInterface.fPeriod = 2;
for ( node = params; node; node = jack_slist_next ( node ) )
{
param = ( const jack_driver_param_t* ) node->data;
switch ( param->character )
{
case 'i':
fCaptureChannels = param->value.ui;
break;
case 'o':
fPlaybackChannels = param->value.ui;
break;
case 'C':
break;
case 'P':
break;
case 'D':
break;
case 'n':
fAudioInterface.fPeriod = param->value.ui;
break;
case 'd':
fAudioInterface.fCardName = strdup ( param->value.str );
break;
case 'r':
fAudioInterface.fFrequency = param->value.ui;
SetAdaptedSampleRate ( param->value.ui );
break;
case 'p':
fAudioInterface.fBuffering = param->value.ui;
SetAdaptedBufferSize ( param->value.ui );
break;
case 'q':
fQuality = param->value.ui;
break;
case 'g':
fRingbufferCurSize = param->value.ui;
fAdaptative = false;
break;
}
}
fAudioInterface.setInputs ( fCaptureChannels );
fAudioInterface.setOutputs ( fPlaybackChannels );
}
void *
jack_port_get_buffer (jack_port_t *port, jack_nframes_t nframes)
{
JSList *node, *next;
/* Output port. The buffer was assigned by the engine
when the port was registered.
*/
if (port->shared->flags & JackPortIsOutput) {
if (port->tied) {
return jack_port_get_buffer (port->tied, nframes);
}
if (port->client_segment_base == NULL || *port->client_segment_base == MAP_FAILED) {
return NULL;
}
return jack_output_port_buffer (port);
}
/* Input port. Since this can only be called from the
process() callback, and since no connections can be
made/broken during this phase (enforced by the jack
server), there is no need to take the connection lock here
*/
if ((node = port->connections) == NULL) {
if (port->client_segment_base == NULL || *port->client_segment_base == MAP_FAILED) {
return NULL;
}
/* no connections; return a zero-filled buffer */
return (void *) (*(port->client_segment_base) + port->type_info->zero_buffer_offset);
}
if ((next = jack_slist_next (node)) == NULL) {
/* one connection: use zero-copy mode - just pass
the buffer of the connected (output) port.
*/
return jack_port_get_buffer (((jack_port_t *) node->data),
nframes);
}
/* Multiple connections. Use a local buffer and mix the
incoming data into that buffer. We have already
established the existence of a mixdown function during the
connection process.
*/
if (port->mix_buffer == NULL) {
jack_error( "internal jack error: mix_buffer not allocated" );
return NULL;
}
port->fptr.mixdown (port, nframes);
return (void *) port->mix_buffer;
}
static jackctl_parameter_t * jackctl_get_parameter(const JSList * parameters_list, const char * parameter_name)
{
while (parameters_list) {
if (strcmp(jackctl_parameter_get_name((jackctl_parameter_t *)parameters_list->data), parameter_name) == 0) {
return (jackctl_parameter_t *)parameters_list->data;
}
parameters_list = jack_slist_next(parameters_list);
}
return NULL;
}
void
latency_cb (jack_latency_callback_mode_t mode, void *arg)
{
jack_latency_range_t range;
JSList *node;
range.min = range.max = target_delay;
if (mode == JackCaptureLatency) {
for (node = capture_ports; node; node = jack_slist_next (node)) {
jack_port_t *port = node->data;
jack_port_set_latency_range (port, mode, &range);
}
} else {
for (node = playback_ports; node; node = jack_slist_next (node)) {
jack_port_t *port = node->data;
jack_port_set_latency_range (port, mode, &range);
}
}
}
static void print_parameters(const JSList * node_ptr)
{
while (node_ptr != NULL) {
jackctl_parameter_t * parameter = (jackctl_parameter_t *)node_ptr->data;
printf("\nparameter name = %s\n", jackctl_parameter_get_name(parameter));
printf("parameter id = %c\n", jackctl_parameter_get_id(parameter));
printf("parameter short decs = %s\n", jackctl_parameter_get_short_description(parameter));
printf("parameter long decs = %s\n", jackctl_parameter_get_long_description(parameter));
print_value(jackctl_parameter_get_default_value(parameter), jackctl_parameter_get_type(parameter));
node_ptr = jack_slist_next(node_ptr);
}
}
static int _return_list(Tcl_Interp *interp, const JSList *list) {
Tcl_Obj *result = Tcl_NewObj();
while (list != NULL) {
if (Tcl_ListObjAppendElement(interp, result, _make_pointer(list->data)) != TCL_OK) {
Tcl_DecrRefCount(result);
return TCL_ERROR;
} else {
list = jack_slist_next(list);
}
}
return fw_success_obj(interp, result);
}
static void print_server_internals(jackctl_server_t *server, FILE* file)
{
const JSList * node_ptr = jackctl_server_get_internals_list(server);
fprintf(file, "Available internals:\n");
while (node_ptr) {
jackctl_internal_t* internal = (jackctl_internal_t *)node_ptr->data;
fprintf(file, " %s\n", jackctl_internal_get_name(internal));
node_ptr = jack_slist_next(node_ptr);
}
fprintf(file, "\n");
}
static void print_server_drivers(jackctl_server_t *server, FILE* file)
{
const JSList * node_ptr = jackctl_server_get_drivers_list(server);
fprintf(file, "Available backends:\n");
while (node_ptr) {
jackctl_driver_t* driver = (jackctl_driver_t *)node_ptr->data;
fprintf(file, " %s (%s)\n", jackctl_driver_get_name(driver), (jackctl_driver_get_type(driver) == JackMaster) ? "master" : "slave");
node_ptr = jack_slist_next(node_ptr);
}
fprintf(file, "\n");
}
static jackctl_internal_t * jackctl_server_get_internal(jackctl_server_t *server, const char *internal_name)
{
const JSList * node_ptr = jackctl_server_get_internals_list(server);
while (node_ptr) {
if (strcmp(jackctl_internal_get_name((jackctl_internal_t *)node_ptr->data), internal_name) == 0) {
return (jackctl_internal_t *)node_ptr->data;
}
node_ptr = jack_slist_next(node_ptr);
}
return NULL;
}
static int iio_driver_detach (iio_driver_t *driver, jack_engine_t *engine) {
JSList *node;
printf("iio_driver_detach\n");
if (driver->engine == 0)
return -1;
// unregister all ports
for (node = driver->capture_ports; node; node = jack_slist_next(node)) {
jack_port_unregister(driver->client, ((jack_port_t *) node->data));
}
jack_slist_free(driver->capture_ports);
driver->capture_ports = 0;
for (node = driver->playback_ports; node; node = jack_slist_next(node)) {
jack_port_unregister(driver->client, ((jack_port_t *) node->data));
}
jack_slist_free(driver->playback_ports);
driver->playback_ports = 0;
driver->engine = 0;
return 0;
}
jack_driver_t *
driver_initialize (jack_client_t *client, const JSList * params)
{
jack_nframes_t sample_rate = 48000;
jack_nframes_t period_size = 1024;
unsigned int capture_ports = 2;
unsigned int playback_ports = 2;
int wait_time_set = 0;
unsigned long wait_time = 0;
const JSList * node;
const jack_driver_param_t * param;
for (node = params; node; node = jack_slist_next (node)) {
param = (const jack_driver_param_t *) node->data;
switch (param->character) {
case 'C':
capture_ports = param->value.ui;
break;
case 'P':
playback_ports = param->value.ui;
break;
case 'r':
sample_rate = param->value.ui;
break;
case 'p':
period_size = param->value.ui;
break;
case 'w':
wait_time = param->value.ui;
wait_time_set = 1;
break;
}
}
if (!wait_time_set)
wait_time = (((float)period_size) / ((float)sample_rate)) * 1000000.0;
return dummy_driver_new (client, "dummy_pcm", capture_ports,
playback_ports, sample_rate, period_size,
wait_time);
}
jack_driver_desc_t *
jack_find_driver_descriptor (JSList * drivers, const char * name)
{
jack_driver_desc_t * desc = 0;
JSList * node;
for (node = drivers; node; node = jack_slist_next (node)) {
desc = (jack_driver_desc_t *) node->data;
if (strcmp (desc->name, name) != 0) {
desc = NULL;
} else {
break;
}
}
return desc;
}
char *map_port_name_to_uuid_port( const char *port_name )
{
JSList *node;
char retval[300];
char *port_component = strchr( port_name,':' );
char *client_component = strdup( port_name );
strchr( client_component, ':' )[0] = '\0';
sprintf( retval, "%s", port_name );
for( node=uuid_map; node; node=jack_slist_next(node) ) {
uuid_map_t *mapping = node->data;
if( !strcmp( mapping->name, client_component ) ) {
sprintf( retval, "%s%s", mapping->uuid, port_component );
break;
}
}
return strdup(retval);
}
jack_port_t *
jack_port_by_id (jack_client_t *client, jack_port_id_t id)
{
JSList *node;
jack_port_t* port;
int need_free = FALSE;
for (node = client->ports_ext; node; node = jack_slist_next (node)) {
port = node->data;
if (port->shared->id == id) { // Found port, return the cached structure
return port;
}
}
// Otherwise possibly allocate a new port structure, keep it in the ports_ext list for later use
port = jack_port_by_id_int (client,id,&need_free);
if (port != NULL && need_free)
client->ports_ext =
jack_slist_prepend (client->ports_ext, port);
return port;
}
static int oss_driver_write (oss_driver_t *driver, jack_nframes_t nframes)
{
int channel;
jack_sample_t *portbuf;
JSList *node;
jack_port_t *port;
if (!driver->run) return 0;
if (nframes != driver->period_size)
{
jack_error(
"OSS: write failed nframes != period_size (%u/%u): %s@%i",
nframes, driver->period_size, __FILE__, __LINE__);
return -1;
}
pthread_mutex_lock(&driver->mutex_out);
node = driver->playback_ports;
channel = 0;
while (node != NULL)
{
port = (jack_port_t *) node->data;
if (jack_port_connected(port))
{
portbuf = jack_port_get_buffer(port, nframes);
copy_and_convert_out(driver->outdevbuf, portbuf,
nframes, channel,
driver->playback_channels,
driver->bits);
}
node = jack_slist_next(node);
channel++;
}
pthread_mutex_unlock(&driver->mutex_out);
return 0;
}
jack_port_t *
jack_port_by_name (jack_client_t *client, const char *port_name)
{
JSList *node;
jack_port_t* port;
for (node = client->ports_ext; node; node = jack_slist_next (node)) {
port = node->data;
if (jack_port_name_equals (port->shared, port_name)) {
/* Found port, return the cached structure. */
return port;
}
}
/* Otherwise allocate a new port structure, keep it in the
* ports_ext list for later use. */
port = jack_port_by_name_int (client, port_name);
if (port != NULL)
client->ports_ext =
jack_slist_prepend (client->ports_ext, port);
return port;
}
static int
coreaudio_driver_read (coreaudio_driver_t *driver, jack_nframes_t nframes)
{
jack_default_audio_sample_t *buf;
channel_t chn;
jack_port_t *port;
JSList *node;
for (chn = 0, node = driver->capture_ports; node; node = jack_slist_next (node), chn++) {
port = (jack_port_t *)node->data;
if (jack_port_connected (port) && (driver->incoreaudio[chn] != NULL)) {
float *in = driver->incoreaudio[chn];
buf = jack_port_get_buffer (port, nframes);
memcpy(buf,in,sizeof(float)*nframes);
}
}
driver->engine->transport_cycle_start (driver->engine,jack_get_microseconds ());
return 0;
}
jack_port_t *
jack_port_by_id_int (const jack_client_t *client, jack_port_id_t id, int* free)
{
JSList *node;
for (node = client->ports; node; node = jack_slist_next (node)) {
if (((jack_port_t *) node->data)->shared->id == id) {
*free = FALSE;
return (jack_port_t *) node->data;
}
}
if (id >= client->engine->port_max)
return NULL;
if (client->engine->ports[id].in_use) {
*free = TRUE;
return jack_port_new (client, id, client->engine);
}
return NULL;
}
JackSapaProxy::JackSapaProxy(jack_client_t* client, const JSList* params)
:fClient(client)
{
jack_log("JackSapaProxy::JackSapaProxy");
fCapturePorts = fPlaybackPorts = 0;
const JSList* node;
const jack_driver_param_t* param;
for (node = params; node; node = jack_slist_next(node)) {
param = (const jack_driver_param_t*)node->data;
switch (param->character) {
case 'C':
fCapturePorts = (param->value.ui > SAPAPROXY_PORT_NUM_FOR_CLIENT)? SAPAPROXY_PORT_NUM_FOR_CLIENT : param->value.ui;
break;
case 'P':
fPlaybackPorts = (param->value.ui > SAPAPROXY_PORT_NUM_FOR_CLIENT)? SAPAPROXY_PORT_NUM_FOR_CLIENT : param->value.ui;
break;
}
}
}
int
jack_port_request_monitor (jack_port_t *port, int onoff)
{
if (onoff) {
port->shared->monitor_requests++;
} else if (port->shared->monitor_requests) {
port->shared->monitor_requests--;
}
if ((port->shared->flags & JackPortIsOutput) == 0) {
JSList *node;
/* this port is for input, so recurse over each of the
connected ports.
*/
pthread_mutex_lock (&port->connection_lock);
for (node = port->connections; node;
node = jack_slist_next (node)) {
/* drop the lock because if there is a feedback loop,
we will deadlock. XXX much worse things will
happen if there is a feedback loop !!!
*/
pthread_mutex_unlock (&port->connection_lock);
jack_port_request_monitor ((jack_port_t *) node->data,
onoff);
pthread_mutex_lock (&port->connection_lock);
}
pthread_mutex_unlock (&port->connection_lock);
}
return 0;
}
