static int oss_driver_attach (oss_driver_t *driver, jack_engine_t *engine)
{
int port_flags;
unsigned int channel;
char channel_name[64];
jack_port_t *port;
jack_latency_range_t range;
driver->engine = engine;
set_period_size(driver, driver->period_size);
if (engine->set_buffer_size(engine, driver->period_size)) {
jack_error ("OSS: cannot set engine buffer size to %d (check MIDI)", driver->period_size);
return -1;
}
engine->set_sample_rate(engine, driver->sample_rate);
port_flags = JackPortIsOutput|JackPortIsPhysical|JackPortIsTerminal;
for (channel = 0; channel < driver->capture_channels; channel++)
{
snprintf(channel_name, sizeof(channel_name),
"capture_%u", channel + 1);
port = jack_port_register(driver->client, channel_name,
JACK_DEFAULT_AUDIO_TYPE, port_flags, 0);
if (port == NULL)
{
jack_error("OSS: cannot register port for %s: %s@%i",
channel_name, __FILE__, __LINE__);
break;
}
range.min = range.max = driver->period_size + driver->sys_in_latency;
jack_port_set_latency_range(port, JackCaptureLatency, &range);
driver->capture_ports =
jack_slist_append(driver->capture_ports, port);
}
port_flags = JackPortIsInput|JackPortIsPhysical|JackPortIsTerminal;
for (channel = 0; channel < driver->playback_channels; channel++)
{
snprintf(channel_name, sizeof(channel_name),
"playback_%u", channel + 1);
port = jack_port_register(driver->client, channel_name,
JACK_DEFAULT_AUDIO_TYPE, port_flags, 0);
if (port == NULL)
{
jack_error("OSS: cannot register port for %s: %s@%i",
channel_name, __FILE__, __LINE__);
break;
}
range.min = range.max = driver->period_size + driver->sys_out_latency;
jack_port_set_latency_range(port, JackPlaybackLatency, &range);
driver->playback_ports =
jack_slist_append(driver->playback_ports, port);
}
jack_activate(driver->client);
return 0;
}
static int
dummy_driver_attach (dummy_driver_t *driver)
{
jack_port_t * port;
char buf[32];
unsigned int chn;
int port_flags;
if (driver->engine->set_buffer_size (driver->engine, driver->period_size)) {
jack_error ("dummy: cannot set engine buffer size to %d (check MIDI)", driver->period_size);
return -1;
}
driver->engine->set_sample_rate (driver->engine, driver->sample_rate);
port_flags = JackPortIsOutput|JackPortIsPhysical|JackPortIsTerminal;
for (chn = 0; chn < driver->capture_channels; chn++)
{
snprintf (buf, sizeof(buf) - 1, "capture_%u", chn+1);
port = jack_port_register (driver->client, buf,
JACK_DEFAULT_AUDIO_TYPE,
port_flags, 0);
if (!port)
{
jack_error ("DUMMY: cannot register port for %s", buf);
break;
}
driver->capture_ports =
jack_slist_append (driver->capture_ports, port);
}
port_flags = JackPortIsInput|JackPortIsPhysical|JackPortIsTerminal;
for (chn = 0; chn < driver->playback_channels; chn++)
{
snprintf (buf, sizeof(buf) - 1, "playback_%u", chn+1);
port = jack_port_register (driver->client, buf,
JACK_DEFAULT_AUDIO_TYPE,
port_flags, 0);
if (!port)
{
jack_error ("DUMMY: cannot register port for %s", buf);
break;
}
driver->playback_ports =
jack_slist_append (driver->playback_ports, port);
}
jack_activate (driver->client);
return 0;
}
static int iio_driver_attach (iio_driver_t *driver, jack_engine_t *engine) {
printf("iio_driver_attach\n");
// create ports
jack_port_t * port;
char buf[32];
unsigned int chn;
int port_flags;
if (driver->engine->set_buffer_size (driver->engine, driver->period_size)) {
jack_error ("iio: cannot set engine buffer size to %d", driver->period_size);
return -1;
}
driver->engine->set_sample_rate (driver->engine, driver->sample_rate);
port_flags = JackPortIsOutput|JackPortIsPhysical|JackPortIsTerminal;
for (chn = 0; chn < driver->capture_channels; chn++) {
snprintf (buf, sizeof(buf) - 1, "capture_%u", chn+1);
port = jack_port_register (driver->client, buf, JACK_DEFAULT_AUDIO_TYPE, port_flags, 0);
if (!port) {
jack_error ("iio: cannot register port for %s", buf);
break;
}
//cout<<"Registered port "<<buf<<endl;
jack_latency_range_t range;
range.min = range.max = 1024;
//cout<<"fix latencies, range currently set to "<<range.min<<", "<<range.max<<endl;
jack_port_set_latency_range (port, JackCaptureLatency, &range);
driver->capture_ports = jack_slist_append (driver->capture_ports, port);
}
port_flags = JackPortIsInput|JackPortIsPhysical|JackPortIsTerminal;
for (chn = 0; chn < driver->playback_channels; chn++) {
snprintf (buf, sizeof(buf) - 1, "playback_%u", chn+1);
port = jack_port_register (driver->client, buf, JACK_DEFAULT_AUDIO_TYPE, port_flags, 0);
if (!port) {
jack_error ("iio: cannot register port for %s", buf);
break;
}
//cout<<"Registered port "<<buf<<endl;
jack_latency_range_t range;
range.min = range.max = 1024;
//cout<<"fix latencies, range currently set to "<<range.min<<", "<<range.max<<endl;
jack_port_set_latency_range (port, JackCaptureLatency, &range);
driver->playback_ports = jack_slist_append (driver->playback_ports, port);
}
return jack_activate (driver->client);
}
JSList *
jack_internals_load (JSList * internals) {
char * driver_dir;
char driver_dir_storage[512];
char dll_filename[512];
WIN32_FIND_DATA filedata;
HANDLE file;
const char * ptr = NULL;
JSList * driver_list = NULL;
jack_driver_desc_t * desc;
if ((driver_dir = getenv("JACK_DRIVER_DIR")) == 0) {
// for WIN32 ADDON_DIR is defined in JackConstants.h as relative path
GetCurrentDirectory(512, driver_dir_storage);
strcat(driver_dir_storage, "/");
strcat(driver_dir_storage, ADDON_DIR);
driver_dir = driver_dir_storage;
}
sprintf(dll_filename, "%s/*.dll", driver_dir);
file = (HANDLE )FindFirstFile(dll_filename, &filedata);
if (file == INVALID_HANDLE_VALUE) {
jack_error("error");
return NULL;
}
do {
ptr = strrchr (filedata.cFileName, '.');
if (!ptr) {
continue;
}
ptr++;
if (strncmp ("dll", ptr, 3) != 0) {
continue;
}
/* check if dll is an internal client */
if (!check_symbol(filedata.cFileName, "jack_internal_initialize")) {
continue;
}
desc = jack_get_descriptor (internals, filedata.cFileName, "jack_get_descriptor");
if (desc) {
driver_list = jack_slist_append (driver_list, desc);
} else {
jack_error ("jack_get_descriptor returns null for \'%s\'", filedata.cFileName);
}
} while (FindNextFile(file, &filedata));
if (!driver_list) {
jack_error ("could not find any internals in %s!", driver_dir);
return NULL;
}
return driver_list;
}
JSList *
jack_internals_load (JSList * internals) {
struct dirent * dir_entry;
DIR * dir_stream;
const char * ptr;
int err;
JSList * driver_list = NULL;
jack_driver_desc_t * desc;
const char* driver_dir;
if ((driver_dir = getenv("JACK_DRIVER_DIR")) == 0) {
driver_dir = ADDON_DIR;
}
/* search through the driver_dir and add get descriptors
from the .so files in it */
dir_stream = opendir (driver_dir);
if (!dir_stream) {
jack_error ("could not open driver directory %s: %s\n",
driver_dir, strerror (errno));
return NULL;
}
while ((dir_entry = readdir(dir_stream))) {
ptr = strrchr (dir_entry->d_name, '.');
if (!ptr) {
continue;
}
ptr++;
if (strncmp ("so", ptr, 2) != 0) {
continue;
}
/* check if dll is an internal client */
if (!check_symbol(dir_entry->d_name, "jack_internal_initialize")) {
continue;
}
desc = jack_get_descriptor (internals, dir_entry->d_name, "jack_get_descriptor");
if (desc) {
driver_list = jack_slist_append (driver_list, desc);
} else {
jack_error ("jack_get_descriptor returns null for \'%s\'", dir_entry->d_name);
}
}
err = closedir (dir_stream);
if (err) {
jack_error ("error closing internal directory %s: %s\n",
driver_dir, strerror (errno));
}
if (!driver_list) {
jack_error ("could not find any internals in %s!", driver_dir);
return NULL;
}
return driver_list;
}
void alloc_ports( int n_capture, int n_playback ) {
int port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;
int chn;
jack_port_t *port;
char buf[32];
capture_ports = NULL;
for (chn = 0; chn < n_capture; chn++)
{
snprintf (buf, sizeof(buf) - 1, "capture_%u", chn+1);
port = jack_port_register (client, buf,
JACK_DEFAULT_AUDIO_TYPE,
port_flags, 0);
if (!port)
{
printf( "jacknet_client: cannot register port for %s", buf);
break;
}
capture_srcs = jack_slist_append( capture_srcs, src_new( 4-samplerate_quality, 1, NULL ) );
capture_ports = jack_slist_append (capture_ports, port);
}
port_flags = JackPortIsInput;
playback_ports = NULL;
for (chn = 0; chn < n_playback; chn++)
{
snprintf (buf, sizeof(buf) - 1, "playback_%u", chn+1);
port = jack_port_register (client, buf,
JACK_DEFAULT_AUDIO_TYPE,
port_flags, 0);
if (!port)
{
printf( "jacknet_client: cannot register port for %s", buf);
break;
}
playback_srcs = jack_slist_append( playback_srcs, src_new( 4-samplerate_quality, 1, NULL ) );
playback_ports = jack_slist_append (playback_ports, port);
}
}
bool jackctl_parameter_set_value(jackctl_parameter_t *parameter_ptr, const union jackctl_parameter_value * value_ptr)
{
bool new_driver_parameter;
/* for driver parameters, set the parameter by adding jack_driver_param_t in the set_parameters list */
if (parameter_ptr->driver_ptr != NULL)
{
/* jack_info("setting driver parameter %p ...", parameter_ptr); */
new_driver_parameter = parameter_ptr->driver_parameter_ptr == NULL;
if (new_driver_parameter)
{
/* jack_info("new driver parameter..."); */
parameter_ptr->driver_parameter_ptr = (jack_driver_param_t *)malloc(sizeof(jack_driver_param_t));
if (parameter_ptr->driver_parameter_ptr == NULL)
{
jack_error ("Allocation of jack_driver_param_t structure failed");
return false;
}
parameter_ptr->driver_parameter_ptr->character = parameter_ptr->id;
parameter_ptr->driver_ptr->set_parameters = jack_slist_append(parameter_ptr->driver_ptr->set_parameters, parameter_ptr->driver_parameter_ptr);
}
switch (parameter_ptr->type)
{
case JackParamInt:
parameter_ptr->driver_parameter_ptr->value.i = value_ptr->i;
break;
case JackParamUInt:
parameter_ptr->driver_parameter_ptr->value.ui = value_ptr->ui;
break;
case JackParamChar:
parameter_ptr->driver_parameter_ptr->value.c = value_ptr->c;
break;
case JackParamString:
strcpy(parameter_ptr->driver_parameter_ptr->value.str, value_ptr->str);
break;
case JackParamBool:
parameter_ptr->driver_parameter_ptr->value.i = value_ptr->b;
break;
default:
jack_error("unknown parameter type %i", (int)parameter_ptr->type);
assert(0);
if (new_driver_parameter)
{
parameter_ptr->driver_ptr->set_parameters = jack_slist_remove(parameter_ptr->driver_ptr->set_parameters, parameter_ptr->driver_parameter_ptr);
}
return false;
}
}
parameter_ptr->is_set = true;
*parameter_ptr->value_ptr = *value_ptr;
return true;
}
static JSList *
jack_drivers_load ()
{
struct dirent * dir_entry;
DIR * dir_stream;
const char * ptr;
int err;
JSList * driver_list = NULL;
jack_driver_desc_t * desc;
char* driver_dir;
if ((driver_dir = getenv("JACK_DRIVER_DIR")) == 0) {
driver_dir = ADDON_DIR;
}
/* search through the driver_dir and add get descriptors
from the .so files in it */
dir_stream = opendir (driver_dir);
if (!dir_stream) {
jack_error ("could not open driver directory %s: %s\n",
driver_dir, strerror (errno));
return NULL;
}
while ( (dir_entry = readdir (dir_stream)) ) {
/* check the filename is of the right format */
if (strncmp ("jack_", dir_entry->d_name, 5) != 0) {
continue;
}
ptr = strrchr (dir_entry->d_name, '.');
if (!ptr) {
continue;
}
ptr++;
if (strncmp ("so", ptr, 2) != 0) {
continue;
}
desc = jack_drivers_get_descriptor (drivers, dir_entry->d_name);
if (desc) {
driver_list = jack_slist_append (driver_list, desc);
}
}
err = closedir (dir_stream);
if (err) {
jack_error ("error closing driver directory %s: %s\n",
driver_dir, strerror (errno));
}
if (!driver_list) {
jack_error ("could not find any drivers in %s!\n", driver_dir);
return NULL;
}
return driver_list;
}
static
struct jackctl_parameter *
jackctl_add_parameter(
JSList ** parameters_list_ptr_ptr,
char id,
const char * name,
const char * short_description,
const char * long_description,
jackctl_param_type_t type,
union jackctl_parameter_value * value_ptr,
union jackctl_parameter_value * default_value_ptr,
union jackctl_parameter_value value,
jack_driver_param_constraint_desc_t * constraint_ptr)
{
struct jackctl_parameter * parameter_ptr;
parameter_ptr = (struct jackctl_parameter *)malloc(sizeof(struct jackctl_parameter));
if (parameter_ptr == NULL)
{
jack_error("Cannot allocate memory for jackctl_parameter structure.");
goto fail;
}
parameter_ptr->name = name;
parameter_ptr->short_description = short_description;
parameter_ptr->long_description = long_description;
parameter_ptr->type = type;
parameter_ptr->is_set = false;
if (value_ptr == NULL)
{
value_ptr = ¶meter_ptr->value;
}
if (default_value_ptr == NULL)
{
default_value_ptr = ¶meter_ptr->default_value;
}
parameter_ptr->value_ptr = value_ptr;
parameter_ptr->default_value_ptr = default_value_ptr;
*value_ptr = *default_value_ptr = value;
parameter_ptr->driver_ptr = NULL;
parameter_ptr->driver_parameter_ptr = NULL;
parameter_ptr->id = id;
parameter_ptr->constraint_ptr = constraint_ptr;
*parameters_list_ptr_ptr = jack_slist_append(*parameters_list_ptr_ptr, parameter_ptr);
return parameter_ptr;
fail:
return NULL;
}
void add_uuid_mapping( const char *uuid ) {
char *clientname = jack_get_client_name_by_uuid( client, uuid );
if( !clientname ) {
printf( "error... cant find client for uuid" );
return;
}
uuid_map_t *mapping = malloc( sizeof(uuid_map_t) );
snprintf( mapping->uuid, sizeof(mapping->uuid), "%s", uuid );
snprintf( mapping->name, sizeof(mapping->name), "%s", clientname );
uuid_map = jack_slist_append( uuid_map, mapping );
}
static int
jackctl_internals_load(
struct jackctl_server * server_ptr)
{
struct jackctl_internal * internal_ptr;
JSList *node_ptr;
JSList *descriptor_node_ptr = NULL;
//XXX: jack1 doesnt support internals enumeration.
//descriptor_node_ptr = jack_internals_load(NULL);
if (descriptor_node_ptr == NULL)
{
return false;
}
while (descriptor_node_ptr != NULL)
{
internal_ptr = (struct jackctl_internal *)malloc(sizeof(struct jackctl_internal));
if (internal_ptr == NULL)
{
jack_error("memory allocation of jackctl_driver structure failed.");
goto next;
}
internal_ptr->desc_ptr = (jack_driver_desc_t *)descriptor_node_ptr->data;
internal_ptr->parameters = NULL;
internal_ptr->set_parameters = NULL;
if (!jackctl_add_driver_parameters((struct jackctl_driver *)internal_ptr))
{
assert(internal_ptr->parameters == NULL);
free(internal_ptr);
goto next;
}
server_ptr->internals = jack_slist_append(server_ptr->internals, internal_ptr);
next:
node_ptr = descriptor_node_ptr;
descriptor_node_ptr = descriptor_node_ptr->next;
free(node_ptr);
}
return true;
}
static int
jackctl_drivers_load(
struct jackctl_server * server_ptr)
{
struct jackctl_driver * driver_ptr;
JSList *node_ptr;
JSList *descriptor_node_ptr;
descriptor_node_ptr = jack_drivers_load();
if (descriptor_node_ptr == NULL)
{
jack_error("could not find any drivers in driver directory!");
return false;
}
while (descriptor_node_ptr != NULL)
{
driver_ptr = (struct jackctl_driver *)malloc(sizeof(struct jackctl_driver));
if (driver_ptr == NULL)
{
jack_error("memory allocation of jackctl_driver structure failed.");
goto next;
}
driver_ptr->desc_ptr = (jack_driver_desc_t *)descriptor_node_ptr->data;
driver_ptr->parameters = NULL;
driver_ptr->set_parameters = NULL;
if (!jackctl_add_driver_parameters(driver_ptr))
{
assert(driver_ptr->parameters == NULL);
free(driver_ptr);
goto next;
}
server_ptr->drivers = jack_slist_append(server_ptr->drivers, driver_ptr);
next:
node_ptr = descriptor_node_ptr;
descriptor_node_ptr = descriptor_node_ptr->next;
free(node_ptr);
}
return true;
}
int
jack_parse_driver_params (jack_driver_desc_t * desc, int argc, char* argv[], JSList ** param_ptr)
{
struct option * long_options;
char * options, * options_ptr;
unsigned long i;
int opt;
unsigned int param_index;
JSList * params = NULL;
jack_driver_param_t * driver_param;
if (argc <= 1) {
*param_ptr = NULL;
return 0;
}
/* check for help */
if (strcmp (argv[1], "-h") == 0 || strcmp (argv[1], "--help") == 0) {
if (argc > 2) {
for (i = 0; i < desc->nparams; i++) {
if (strcmp (desc->params[i].name, argv[2]) == 0) {
jack_print_driver_param_usage (desc, i, stdout);
return 1;
}
}
fprintf (stderr, "jackd: unknown option '%s' "
"for driver '%s'\n", argv[2],
desc->name);
}
jack_log("Parameters for driver '%s' (all parameters are optional):", desc->name);
jack_print_driver_options (desc, stdout);
return 1;
}
/* set up the stuff for getopt */
options = (char*)calloc (desc->nparams * 3 + 1, sizeof (char));
long_options = (option*)calloc (desc->nparams + 1, sizeof (struct option));
options_ptr = options;
for (i = 0; i < desc->nparams; i++) {
sprintf (options_ptr, "%c::", desc->params[i].character);
options_ptr += 3;
long_options[i].name = desc->params[i].name;
long_options[i].flag = NULL;
long_options[i].val = desc->params[i].character;
long_options[i].has_arg = optional_argument;
}
/* create the params */
optind = 0;
opterr = 0;
while ((opt = getopt_long(argc, argv, options, long_options, NULL)) != -1) {
if (opt == ':' || opt == '?') {
if (opt == ':') {
fprintf (stderr, "Missing option to argument '%c'\n", optopt);
} else {
fprintf (stderr, "Unknownage with option '%c'\n", optopt);
}
fprintf (stderr, "Options for driver '%s':\n", desc->name);
jack_print_driver_options (desc, stderr);
return 1;
}
for (param_index = 0; param_index < desc->nparams; param_index++) {
if (opt == desc->params[param_index].character) {
break;
}
}
driver_param = (jack_driver_param_t*)calloc (1, sizeof (jack_driver_param_t));
driver_param->character = desc->params[param_index].character;
if (!optarg && optind < argc &&
strlen(argv[optind]) &&
argv[optind][0] != '-') {
optarg = argv[optind];
}
if (optarg) {
switch (desc->params[param_index].type) {
case JackDriverParamInt:
driver_param->value.i = atoi (optarg);
break;
case JackDriverParamUInt:
driver_param->value.ui = strtoul (optarg, NULL, 10);
break;
case JackDriverParamChar:
driver_param->value.c = optarg[0];
break;
case JackDriverParamString:
strncpy (driver_param->value.str, optarg, JACK_DRIVER_PARAM_STRING_MAX);
break;
case JackDriverParamBool:
/*
if (strcasecmp ("false", optarg) == 0 ||
strcasecmp ("off", optarg) == 0 ||
strcasecmp ("no", optarg) == 0 ||
strcasecmp ("0", optarg) == 0 ||
strcasecmp ("(null)", optarg) == 0 ) {
*/
// steph
if (strcmp ("false", optarg) == 0 ||
strcmp ("off", optarg) == 0 ||
strcmp ("no", optarg) == 0 ||
strcmp ("0", optarg) == 0 ||
strcmp ("(null)", optarg) == 0 ) {
driver_param->value.i = false;
} else {
driver_param->value.i = true;
}
break;
}
} else {
if (desc->params[param_index].type == JackDriverParamBool) {
driver_param->value.i = true;
} else {
driver_param->value = desc->params[param_index].value;
}
}
params = jack_slist_append (params, driver_param);
}
free (options);
free (long_options);
if (param_ptr)
*param_ptr = params;
return 0;
}
int
main (int argc, char *argv[])
{
jack_driver_desc_t * desc;
int replace_registry = 0;
int do_sanity_checks = 1;
int show_version = 0;
#ifdef HAVE_ZITA_BRIDGE_DEPS
const char *options = "A:d:P:uvshVrRZTFlI:t:mM:n:Np:c:X:C:";
#else
const char *options = "A:d:P:uvshVrRZTFlI:t:mM:n:Np:c:X:C:";
#endif
struct option long_options[] =
{
/* keep ordered by single-letter option code */
#ifdef HAVE_ZITA_BRIDGE_DEPS
{ "alsa-add", 1, 0, 'A' },
#endif
{ "clock-source", 1, 0, 'c' },
{ "driver", 1, 0, 'd' },
{ "help", 0, 0, 'h' },
{ "tmpdir-location", 0, 0, 'l' },
{ "internal-client", 0, 0, 'I' },
{ "no-mlock", 0, 0, 'm' },
{ "midi-bufsize", 1, 0, 'M' },
{ "name", 1, 0, 'n' },
{ "no-sanity-checks", 0, 0, 'N' },
{ "port-max", 1, 0, 'p' },
{ "realtime-priority", 1, 0, 'P' },
{ "no-realtime", 0, 0, 'r' },
{ "realtime", 0, 0, 'R' },
{ "replace-registry", 0, &replace_registry, 0 },
{ "silent", 0, 0, 's' },
{ "sync", 0, 0, 'S' },
{ "timeout", 1, 0, 't' },
{ "temporary", 0, 0, 'T' },
{ "unlock", 0, 0, 'u' },
{ "version", 0, 0, 'V' },
{ "verbose", 0, 0, 'v' },
{ "slave-driver", 1, 0, 'X' },
{ "nozombies", 0, 0, 'Z' },
{ "timeout-thres", 2, 0, 'C' },
{ 0, 0, 0, 0 }
};
int opt = 0;
int option_index = 0;
int seen_driver = 0;
char *driver_name = NULL;
char **driver_args = NULL;
JSList * driver_params;
JSList * slave_drivers = NULL;
JSList * load_list = NULL;
size_t midi_buffer_size = 0;
int driver_nargs = 1;
int i;
int rc;
#ifdef HAVE_ZITA_BRIDGE_DEPS
const char* alsa_add_client_name_playback = "zalsa_out";
const char* alsa_add_client_name_capture = "zalsa_in";
char alsa_add_args[64];
char* dirstr;
#endif
setvbuf (stdout, NULL, _IOLBF, 0);
maybe_use_capabilities ();
opterr = 0;
while (!seen_driver &&
(opt = getopt_long (argc, argv, options,
long_options, &option_index)) != EOF) {
switch (opt) {
#ifdef HAVE_ZITA_BRIDGE_DEPS
case 'A':
/* add a new internal client named after the ALSA device name
given as optarg, using the last character 'p' or 'c' to
indicate playback or capture. If there isn't one,
assume capture (common case: USB mics etc.)
*/
if ((dirstr = strstr (optarg, "%p")) != NULL && dirstr == (optarg + strlen(optarg) - 2)) {
snprintf (alsa_add_args, sizeof (alsa_add_args), "%.*s_play:%s/-dhw:%.*s",
(int) strlen (optarg) - 2, optarg,
alsa_add_client_name_playback,
(int) strlen (optarg) - 2, optarg);
load_list = jack_slist_append(load_list, strdup (alsa_add_args));
} else if ((dirstr = strstr (optarg, "%c")) != NULL && dirstr == (optarg + strlen(optarg) - 2)) {
snprintf (alsa_add_args, sizeof (alsa_add_args), "%.*s_rec:%s/-dhw:%.*s",
(int) strlen (optarg) - 2, optarg,
alsa_add_client_name_capture,
(int) strlen (optarg) - 2, optarg);
load_list = jack_slist_append(load_list, strdup (alsa_add_args));
} else {
snprintf (alsa_add_args, sizeof (alsa_add_args), "%s_play:%s/-dhw:%s",
optarg,
alsa_add_client_name_playback,
optarg);
load_list = jack_slist_append(load_list, strdup (alsa_add_args));
snprintf (alsa_add_args, sizeof (alsa_add_args), "%s_rec:%s/-dhw:%s",
optarg,
alsa_add_client_name_capture,
optarg);
load_list = jack_slist_append(load_list, strdup (alsa_add_args));
}
break;
#endif
case 'c':
if (tolower (optarg[0]) == 'h') {
clock_source = JACK_TIMER_HPET;
} else if (tolower (optarg[0]) == 'c') {
/* For backwards compatibility with scripts,
* allow the user to request the cycle clock
* on the command line, but use the system
* clock instead
*/
clock_source = JACK_TIMER_SYSTEM_CLOCK;
} else if (tolower (optarg[0]) == 's') {
clock_source = JACK_TIMER_SYSTEM_CLOCK;
} else {
usage (stderr);
return -1;
}
break;
case 'C':
if (optarg)
timeout_count_threshold = atoi (optarg);
else
timeout_count_threshold = 250;
break;
case 'd':
seen_driver = optind + 1;
driver_name = optarg;
break;
case 'D':
frame_time_offset = JACK_MAX_FRAMES - atoi(optarg);
break;
case 'l':
/* special flag to allow libjack to determine jackd's idea of where tmpdir is */
printf ("%s\n", jack_tmpdir);
exit (0);
case 'I':
load_list = jack_slist_append(load_list, optarg);
break;
case 'm':
do_mlock = 0;
break;
case 'M':
midi_buffer_size = (unsigned int) atol (optarg);
break;
case 'n':
server_name = optarg;
break;
case 'N':
do_sanity_checks = 0;
break;
case 'p':
port_max = (unsigned int) atol (optarg);
break;
case 'P':
realtime_priority = atoi (optarg);
break;
case 'r':
realtime = 0;
break;
case 'R':
/* this is now the default */
realtime = 1;
break;
case 's':
jack_set_error_function (silent_jack_error_callback);
break;
case 'S':
/* this option is for jack2 only (synchronous mode) */
break;
case 'T':
temporary = 1;
break;
case 't':
client_timeout = atoi (optarg);
break;
case 'u':
do_unlock = 1;
break;
case 'v':
verbose = 1;
break;
case 'V':
show_version = 1;
break;
case 'X':
slave_drivers = jack_slist_append(slave_drivers, optarg);
break;
case 'Z':
nozombies = 1;
break;
default:
jack_error ("Unknown option character %c",
optopt);
/*fallthru*/
case 'h':
usage (stdout);
return -1;
}
}
if (show_version) {
printf ( "jackd version " VERSION
" tmpdir " DEFAULT_TMP_DIR
" protocol " PROTOCOL_VERSION
"\n");
return 0;
}
copyright (stdout);
if (do_sanity_checks && (0 < sanitycheck (realtime, FALSE))) {
return -1;
}
if (!seen_driver) {
usage (stderr);
exit (1);
}
/* DIRTY HACK needed to pick up -X supplied as part of ALSA driver args. This is legacy
hack to make control apps like qjackctl based on the < 0.124 command line interface
continue to work correctly.
If -X seq was given as part of the driver args, load the ALSA MIDI slave driver.
*/
for (i = seen_driver; i < argc; ++i) {
if (strcmp (argv[i], "-X") == 0) {
if (argc >= i + 2) {
if (strcmp (argv[i+1], "seq") == 0) {
slave_drivers = jack_slist_append (slave_drivers,"alsa_midi");
}
}
break;
} else if (strcmp (argv[i], "-Xseq") == 0) {
slave_drivers = jack_slist_append (slave_drivers,"alsa_midi");
break;
}
}
drivers = jack_drivers_load ();
if (!drivers) {
fprintf (stderr, "jackd: no drivers found; exiting\n");
exit (1);
}
if (midi_buffer_size != 0) {
jack_port_type_info_t* port_type = &jack_builtin_port_types[JACK_MIDI_PORT_TYPE];
port_type->buffer_size = midi_buffer_size * jack_midi_internal_event_size ();
port_type->buffer_scale_factor = -1;
if (verbose) {
fprintf (stderr, "Set MIDI buffer size to %u bytes\n", port_type->buffer_size);
}
}
desc = jack_find_driver_descriptor (driver_name);
if (!desc) {
fprintf (stderr, "jackd: unknown driver '%s'\n", driver_name);
exit (1);
}
if (optind < argc) {
driver_nargs = 1 + argc - optind;
} else {
driver_nargs = 1;
}
if (driver_nargs == 0) {
fprintf (stderr, "No driver specified ... hmm. JACK won't do"
" anything when run like this.\n");
return -1;
}
driver_args = (char **) malloc (sizeof (char *) * driver_nargs);
driver_args[0] = driver_name;
for (i = 1; i < driver_nargs; i++) {
driver_args[i] = argv[optind++];
}
if (jack_parse_driver_params (desc, driver_nargs,
driver_args, &driver_params)) {
exit (0);
}
if (server_name == NULL)
server_name = jack_default_server_name ();
rc = jack_register_server (server_name, replace_registry);
switch (rc) {
case EEXIST:
fprintf (stderr, "`%s' server already active\n", server_name);
exit (1);
case ENOSPC:
fprintf (stderr, "too many servers already active\n");
exit (2);
case ENOMEM:
fprintf (stderr, "no access to shm registry\n");
exit (3);
default:
if (verbose)
fprintf (stderr, "server `%s' registered\n",
server_name);
}
/* clean up shared memory and files from any previous
* instance of this server name */
jack_cleanup_shm ();
jack_cleanup_files (server_name);
/* run the server engine until it terminates */
jack_main (desc, driver_params, slave_drivers, load_list);
/* clean up shared memory and files from this server instance */
if (verbose)
fprintf (stderr, "cleaning up shared memory\n");
jack_cleanup_shm ();
if (verbose)
fprintf (stderr, "cleaning up files\n");
jack_cleanup_files (server_name);
if (verbose)
fprintf (stderr, "unregistering server `%s'\n", server_name);
jack_unregister_server (server_name);
exit (0);
}
/**
* This Function allocates all the I/O Ports which are added the lists.
*/
void
alloc_ports (int n_capture_audio, int n_playback_audio, int n_capture_midi, int n_playback_midi)
{
int port_flags = JackPortIsOutput;
int chn;
jack_port_t *port;
char buf[32];
capture_ports = NULL;
/* Allocate audio capture channels */
for (chn = 0; chn < n_capture_audio; chn++)
{
snprintf (buf, sizeof (buf) - 1, "capture_%u", chn + 1);
port = jack_port_register (client, buf, JACK_DEFAULT_AUDIO_TYPE, port_flags, 0);
if (!port)
{
printf( "jack_netsource: cannot register %s port\n", buf);
break;
}
if( bitdepth == 1000 ) {
#if HAVE_CELT
#if HAVE_CELT_API_0_7 || HAVE_CELT_API_0_8
CELTMode *celt_mode = celt_mode_create( jack_get_sample_rate( client ), jack_get_buffer_size(client), NULL );
capture_srcs = jack_slist_append(capture_srcs, celt_decoder_create( celt_mode, 1, NULL ) );
#else
CELTMode *celt_mode = celt_mode_create( jack_get_sample_rate( client ), 1, jack_get_buffer_size(client), NULL );
capture_srcs = jack_slist_append(capture_srcs, celt_decoder_create( celt_mode ) );
#endif
#endif
} else {
#if HAVE_SAMPLERATE
capture_srcs = jack_slist_append (capture_srcs, src_new (SRC_LINEAR, 1, NULL));
#endif
}
capture_ports = jack_slist_append (capture_ports, port);
}
/* Allocate midi capture channels */
for (chn = n_capture_audio; chn < n_capture_midi + n_capture_audio; chn++)
{
snprintf (buf, sizeof (buf) - 1, "capture_%u", chn + 1);
port = jack_port_register (client, buf, JACK_DEFAULT_MIDI_TYPE, port_flags, 0);
if (!port)
{
printf ("jack_netsource: cannot register %s port\n", buf);
break;
}
capture_ports = jack_slist_append(capture_ports, port);
}
/* Allocate audio playback channels */
port_flags = JackPortIsInput;
playback_ports = NULL;
for (chn = 0; chn < n_playback_audio; chn++)
{
snprintf (buf, sizeof (buf) - 1, "playback_%u", chn + 1);
port = jack_port_register (client, buf, JACK_DEFAULT_AUDIO_TYPE, port_flags, 0);
if (!port)
{
printf ("jack_netsource: cannot register %s port\n", buf);
break;
}
if( bitdepth == 1000 ) {
#if HAVE_CELT
#if HAVE_CELT_API_0_7 || HAVE_CELT_API_0_8
CELTMode *celt_mode = celt_mode_create( jack_get_sample_rate (client), jack_get_buffer_size(client), NULL );
playback_srcs = jack_slist_append(playback_srcs, celt_encoder_create( celt_mode, 1, NULL ) );
#else
CELTMode *celt_mode = celt_mode_create( jack_get_sample_rate (client), 1, jack_get_buffer_size(client), NULL );
playback_srcs = jack_slist_append(playback_srcs, celt_encoder_create( celt_mode ) );
#endif
#endif
} else {
#if HAVE_SAMPLERATE
playback_srcs = jack_slist_append (playback_srcs, src_new (SRC_LINEAR, 1, NULL));
#endif
}
playback_ports = jack_slist_append (playback_ports, port);
}
/* Allocate midi playback channels */
for (chn = n_playback_audio; chn < n_playback_midi + n_playback_audio; chn++)
{
snprintf (buf, sizeof (buf) - 1, "playback_%u", chn + 1);
port = jack_port_register (client, buf, JACK_DEFAULT_MIDI_TYPE, port_flags, 0);
if (!port)
{
printf ("jack_netsource: cannot register %s port\n", buf);
break;
}
playback_ports = jack_slist_append (playback_ports, port);
}
}
void netjack_attach( netjack_driver_state_t *netj )
{
//puts ("net_driver_attach");
jack_port_t * port;
char buf[32];
unsigned int chn;
int port_flags;
if( netj->bitdepth == CELT_MODE )
{
#if HAVE_CELT
#if HAVE_CELT_API_0_7 || HAVE_CELT_API_0_8
celt_int32 lookahead;
netj->celt_mode = celt_mode_create( netj->sample_rate, netj->period_size, NULL );
#else
celt_int32_t lookahead;
netj->celt_mode = celt_mode_create( netj->sample_rate, 1, netj->period_size, NULL );
#endif
celt_mode_info( netj->celt_mode, CELT_GET_LOOKAHEAD, &lookahead );
netj->codec_latency = 2*lookahead;
#endif
}
if (netj->handle_transport_sync)
jack_set_sync_callback(netj->client, (JackSyncCallback) net_driver_sync_cb, NULL);
port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;
for (chn = 0; chn < netj->capture_channels_audio; chn++) {
snprintf (buf, sizeof(buf) - 1, "capture_%u", chn + 1);
port = jack_port_register (netj->client, buf,
JACK_DEFAULT_AUDIO_TYPE,
port_flags, 0);
if (!port) {
jack_error ("NET: cannot register port for %s", buf);
break;
}
netj->capture_ports =
jack_slist_append (netj->capture_ports, port);
if( netj->bitdepth == CELT_MODE ) {
#if HAVE_CELT
#if HAVE_CELT_API_0_7 || HAVE_CELT_API_0_8
netj->capture_srcs = jack_slist_append(netj->capture_srcs, celt_decoder_create( netj->celt_mode, 1, NULL ) );
#else
netj->capture_srcs = jack_slist_append(netj->capture_srcs, celt_decoder_create( netj->celt_mode ) );
#endif
#endif
} else {
#if HAVE_SAMPLERATE
netj->capture_srcs = jack_slist_append(netj->capture_srcs, src_new(SRC_LINEAR, 1, NULL));
#endif
}
}
for (chn = netj->capture_channels_audio; chn < netj->capture_channels; chn++) {
snprintf (buf, sizeof(buf) - 1, "capture_%u", chn + 1);
port = jack_port_register (netj->client, buf,
JACK_DEFAULT_MIDI_TYPE,
port_flags, 0);
if (!port) {
jack_error ("NET: cannot register port for %s", buf);
break;
}
netj->capture_ports =
jack_slist_append (netj->capture_ports, port);
}
port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;
for (chn = 0; chn < netj->playback_channels_audio; chn++) {
snprintf (buf, sizeof(buf) - 1, "playback_%u", chn + 1);
port = jack_port_register (netj->client, buf,
JACK_DEFAULT_AUDIO_TYPE,
port_flags, 0);
if (!port) {
jack_error ("NET: cannot register port for %s", buf);
break;
}
netj->playback_ports =
jack_slist_append (netj->playback_ports, port);
if( netj->bitdepth == CELT_MODE ) {
#if HAVE_CELT
#if HAVE_CELT_API_0_7 || HAVE_CELT_API_0_8
CELTMode *celt_mode = celt_mode_create( netj->sample_rate, netj->period_size, NULL );
netj->playback_srcs = jack_slist_append(netj->playback_srcs, celt_encoder_create( celt_mode, 1, NULL ) );
#else
CELTMode *celt_mode = celt_mode_create( netj->sample_rate, 1, netj->period_size, NULL );
netj->playback_srcs = jack_slist_append(netj->playback_srcs, celt_encoder_create( celt_mode ) );
#endif
#endif
} else {
#if HAVE_SAMPLERATE
netj->playback_srcs = jack_slist_append(netj->playback_srcs, src_new(SRC_LINEAR, 1, NULL));
#endif
}
}
for (chn = netj->playback_channels_audio; chn < netj->playback_channels; chn++) {
snprintf (buf, sizeof(buf) - 1, "playback_%u", chn + 1);
port = jack_port_register (netj->client, buf,
JACK_DEFAULT_MIDI_TYPE,
port_flags, 0);
if (!port) {
jack_error ("NET: cannot register port for %s", buf);
break;
}
netj->playback_ports =
jack_slist_append (netj->playback_ports, port);
}
jack_activate (netj->client);
}
void netjack_attach( netjack_driver_state_t *netj )
{
//puts ("net_driver_attach");
jack_port_t * port;
char buf[32];
unsigned int chn;
int port_flags;
if( netj->bitdepth == CELT_MODE ) {
#if HAVE_CELT
#if HAVE_CELT_API_0_7 || HAVE_CELT_API_0_8 || HAVE_CELT_API_0_11
celt_int32 lookahead;
netj->celt_mode = celt_mode_create( netj->sample_rate, netj->period_size, NULL );
#else
celt_int32_t lookahead;
netj->celt_mode = celt_mode_create( netj->sample_rate, 1, netj->period_size, NULL );
#endif
celt_mode_info( netj->celt_mode, CELT_GET_LOOKAHEAD, &lookahead );
netj->codec_latency = 2 * lookahead;
#endif
}
if( netj->bitdepth == OPUS_MODE ) {
#if HAVE_OPUS
netj->opus_mode = opus_custom_mode_create(netj->sample_rate, netj->period_size, NULL);
#endif
}
if (netj->handle_transport_sync)
jack_set_sync_callback(netj->client, (JackSyncCallback) net_driver_sync_cb, NULL);
port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;
for (chn = 0; chn < netj->capture_channels_audio; chn++) {
snprintf (buf, sizeof(buf) - 1, "capture_%u", chn + 1);
port = jack_port_register (netj->client, buf,
JACK_DEFAULT_AUDIO_TYPE,
port_flags, 0);
if (!port) {
jack_error ("NET: cannot register port for %s", buf);
break;
}
netj->capture_ports =
jack_slist_append (netj->capture_ports, port);
if( netj->bitdepth == CELT_MODE ) {
#if HAVE_CELT
#if HAVE_CELT_API_0_11
netj->capture_srcs = jack_slist_append(netj->capture_srcs, celt_decoder_create_custom( netj->celt_mode, 1, NULL ) );
#elif HAVE_CELT_API_0_7 || HAVE_CELT_API_0_8
netj->capture_srcs = jack_slist_append(netj->capture_srcs, celt_decoder_create( netj->celt_mode, 1, NULL ) );
#else
netj->capture_srcs = jack_slist_append(netj->capture_srcs, celt_decoder_create( netj->celt_mode ) );
#endif
#endif
} else if( netj->bitdepth == OPUS_MODE ) {
#if HAVE_OPUS
OpusCustomDecoder *decoder = opus_custom_decoder_create( netj->opus_mode, 1, NULL );
netj->capture_srcs = jack_slist_append(netj->capture_srcs, decoder );
#endif
} else {
#if HAVE_SAMPLERATE
netj->capture_srcs = jack_slist_append(netj->capture_srcs, src_new(SRC_LINEAR, 1, NULL));
#endif
}
}
for (chn = netj->capture_channels_audio; chn < netj->capture_channels; chn++) {
snprintf (buf, sizeof(buf) - 1, "capture_%u", chn + 1);
port = jack_port_register (netj->client, buf,
JACK_DEFAULT_MIDI_TYPE,
port_flags, 0);
if (!port) {
jack_error ("NET: cannot register port for %s", buf);
break;
}
netj->capture_ports =
jack_slist_append (netj->capture_ports, port);
}
port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;
for (chn = 0; chn < netj->playback_channels_audio; chn++) {
snprintf (buf, sizeof(buf) - 1, "playback_%u", chn + 1);
port = jack_port_register (netj->client, buf,
JACK_DEFAULT_AUDIO_TYPE,
port_flags, 0);
if (!port) {
jack_error ("NET: cannot register port for %s", buf);
break;
}
netj->playback_ports =
jack_slist_append (netj->playback_ports, port);
if( netj->bitdepth == CELT_MODE ) {
#if HAVE_CELT
#if HAVE_CELT_API_0_11
CELTMode *celt_mode = celt_mode_create( netj->sample_rate, netj->period_size, NULL );
netj->playback_srcs = jack_slist_append(netj->playback_srcs, celt_decoder_create_custom( celt_mode, 1, NULL ) );
#elif HAVE_CELT_API_0_7 || HAVE_CELT_API_0_8
CELTMode *celt_mode = celt_mode_create( netj->sample_rate, netj->period_size, NULL );
netj->playback_srcs = jack_slist_append(netj->playback_srcs, celt_encoder_create( celt_mode, 1, NULL ) );
#else
CELTMode *celt_mode = celt_mode_create( netj->sample_rate, 1, netj->period_size, NULL );
netj->playback_srcs = jack_slist_append(netj->playback_srcs, celt_encoder_create( celt_mode ) );
#endif
#endif
} else if( netj->bitdepth == OPUS_MODE ) {
#if HAVE_OPUS
const int kbps = netj->resample_factor;
jack_log( "OPUS %dkbps\n", kbps);
OpusCustomMode *opus_mode = opus_custom_mode_create( netj->sample_rate, netj->period_size, NULL ); // XXX free me in the end
OpusCustomEncoder *oe = opus_custom_encoder_create( opus_mode, 1, NULL );
opus_custom_encoder_ctl(oe, OPUS_SET_BITRATE(kbps*1024)); // bits per second
opus_custom_encoder_ctl(oe, OPUS_SET_COMPLEXITY(10));
opus_custom_encoder_ctl(oe, OPUS_SET_SIGNAL(OPUS_SIGNAL_MUSIC));
opus_custom_encoder_ctl(oe, OPUS_SET_SIGNAL(OPUS_APPLICATION_RESTRICTED_LOWDELAY));
netj->playback_srcs = jack_slist_append(netj->playback_srcs, oe );
#endif
} else {
#if HAVE_SAMPLERATE
netj->playback_srcs = jack_slist_append(netj->playback_srcs, src_new(SRC_LINEAR, 1, NULL));
#endif
}
}
for (chn = netj->playback_channels_audio; chn < netj->playback_channels; chn++) {
snprintf (buf, sizeof(buf) - 1, "playback_%u", chn + 1);
port = jack_port_register (netj->client, buf,
JACK_DEFAULT_MIDI_TYPE,
port_flags, 0);
if (!port) {
jack_error ("NET: cannot register port for %s", buf);
break;
}
netj->playback_ports =
jack_slist_append (netj->playback_ports, port);
}
jack_activate (netj->client);
}
static int
coreaudio_driver_attach (coreaudio_driver_t *driver, jack_engine_t *engine)
{
jack_port_t *port;
int port_flags;
channel_t chn;
char buf[JACK_PORT_NAME_SIZE];
driver->engine = engine;
driver->engine->set_buffer_size (engine, driver->frames_per_cycle);
driver->engine->set_sample_rate (engine, driver->frame_rate);
port_flags = JackPortIsOutput|JackPortIsPhysical|JackPortIsTerminal;
/*
if (driver->has_hw_monitoring) {
port_flags |= JackPortCanMonitor;
}
*/
for (chn = 0; chn < driver->capture_nchannels; chn++) {
//snprintf (buf, sizeof(buf) - 1, "capture_%lu", chn+1);
snprintf (buf, sizeof(buf) - 1, "%s:out%lu", driver->driver_name, chn+1);
if ((port = jack_port_register (driver->client, buf, JACK_DEFAULT_AUDIO_TYPE, port_flags, 0)) == NULL) {
jack_error ("coreaudio: cannot register port for %s", buf);
break;
}
/* XXX fix this so that it can handle: systemic (external) latency
*/
jack_port_set_latency (port, driver->frames_per_cycle);
driver->capture_ports = jack_slist_append (driver->capture_ports, port);
}
port_flags = JackPortIsInput|JackPortIsPhysical|JackPortIsTerminal;
for (chn = 0; chn < driver->playback_nchannels; chn++) {
//snprintf (buf, sizeof(buf) - 1, "playback_%lu", chn+1);
snprintf (buf, sizeof(buf) - 1, "%s:in%lu", driver->driver_name, chn+1);
if ((port = jack_port_register (driver->client, buf, JACK_DEFAULT_AUDIO_TYPE, port_flags, 0)) == NULL) {
jack_error ("coreaudio: cannot register port for %s", buf);
break;
}
/* XXX fix this so that it can handle: systemic (external) latency
*/
jack_port_set_latency (port, driver->frames_per_cycle);
driver->playback_ports = jack_slist_append (driver->playback_ports, port);
}
jack_activate (driver->client);
return 0;
}
/**
* This Function allocates all the I/O Ports which are added the lists.
*/
void
alloc_ports (int n_capture_audio, int n_playback_audio, int n_capture_midi, int n_playback_midi)
{
int port_flags = JackPortIsOutput;
int chn;
jack_port_t *port;
char buf[32];
capture_ports = NULL;
/* Allocate audio capture channels */
for (chn = 0; chn < n_capture_audio; chn++) {
snprintf (buf, sizeof (buf) - 1, "capture_%u", chn + 1);
port = jack_port_register (client, buf, JACK_DEFAULT_AUDIO_TYPE, port_flags, 0);
if (!port) {
printf( "jack_netsource: cannot register %s port\n", buf);
break;
}
if (bitdepth == 1000) {
#if HAVE_CELT
#if HAVE_CELT_API_0_11
CELTMode *celt_mode = celt_mode_create( jack_get_sample_rate( client ), jack_get_buffer_size(client), NULL );
capture_srcs = jack_slist_append(capture_srcs, celt_decoder_create_custom( celt_mode, 1, NULL ) );
#elif HAVE_CELT_API_0_7 || HAVE_CELT_API_0_8
CELTMode *celt_mode = celt_mode_create( jack_get_sample_rate( client ), jack_get_buffer_size(client), NULL );
capture_srcs = jack_slist_append(capture_srcs, celt_decoder_create( celt_mode, 1, NULL ) );
#else
CELTMode *celt_mode = celt_mode_create( jack_get_sample_rate( client ), 1, jack_get_buffer_size(client), NULL );
capture_srcs = jack_slist_append(capture_srcs, celt_decoder_create( celt_mode ) );
#endif
#endif
} else if (bitdepth == 999) {
#if HAVE_OPUS
int err;
OpusCustomMode *opus_mode = opus_custom_mode_create(jack_get_sample_rate( client ), jack_get_buffer_size(client), &err);
if (err != OPUS_OK) { printf("OPUS MODE FAILED\n"); }
OpusCustomDecoder *decoder = opus_custom_decoder_create(opus_mode, 1, &err);
if (err != OPUS_OK) { printf("OPUS DECODER FAILED\n"); }
opus_custom_decoder_init(decoder, opus_mode, 1);
capture_srcs = jack_slist_append(capture_srcs, decoder);
#endif
} else {
#if HAVE_SAMPLERATE
capture_srcs = jack_slist_append (capture_srcs, src_new (SRC_LINEAR, 1, NULL));
#endif
}
capture_ports = jack_slist_append (capture_ports, port);
}
/* Allocate midi capture channels */
for (chn = n_capture_audio; chn < n_capture_midi + n_capture_audio; chn++) {
snprintf (buf, sizeof (buf) - 1, "capture_%u", chn + 1);
port = jack_port_register (client, buf, JACK_DEFAULT_MIDI_TYPE, port_flags, 0);
if (!port) {
printf ("jack_netsource: cannot register %s port\n", buf);
break;
}
capture_ports = jack_slist_append(capture_ports, port);
}
/* Allocate audio playback channels */
port_flags = JackPortIsInput;
playback_ports = NULL;
for (chn = 0; chn < n_playback_audio; chn++) {
snprintf (buf, sizeof (buf) - 1, "playback_%u", chn + 1);
port = jack_port_register (client, buf, JACK_DEFAULT_AUDIO_TYPE, port_flags, 0);
if (!port) {
printf ("jack_netsource: cannot register %s port\n", buf);
break;
}
if( bitdepth == 1000 ) {
#if HAVE_CELT
#if HAVE_CELT_API_0_11
CELTMode *celt_mode = celt_mode_create( jack_get_sample_rate (client), jack_get_buffer_size(client), NULL );
playback_srcs = jack_slist_append(playback_srcs, celt_encoder_create_custom( celt_mode, 1, NULL ) );
#elif HAVE_CELT_API_0_7 || HAVE_CELT_API_0_8
CELTMode *celt_mode = celt_mode_create( jack_get_sample_rate (client), jack_get_buffer_size(client), NULL );
playback_srcs = jack_slist_append(playback_srcs, celt_encoder_create( celt_mode, 1, NULL ) );
#else
CELTMode *celt_mode = celt_mode_create( jack_get_sample_rate (client), 1, jack_get_buffer_size(client), NULL );
playback_srcs = jack_slist_append(playback_srcs, celt_encoder_create( celt_mode ) );
#endif
#endif
} else if( bitdepth == 999 ) {
#if HAVE_OPUS
const int kbps = factor;
printf("new opus encoder %d kbps\n", kbps);
int err;
OpusCustomMode *opus_mode = opus_custom_mode_create(jack_get_sample_rate (client), jack_get_buffer_size(client), &err ); // XXX free me
if (err != OPUS_OK) { printf("OPUS MODE FAILED\n"); }
OpusCustomEncoder *oe = opus_custom_encoder_create( opus_mode, 1, &err );
if (err != OPUS_OK) { printf("OPUS ENCODER FAILED\n"); }
opus_custom_encoder_ctl(oe, OPUS_SET_BITRATE(kbps*1024)); // bits per second
opus_custom_encoder_ctl(oe, OPUS_SET_COMPLEXITY(10));
opus_custom_encoder_ctl(oe, OPUS_SET_SIGNAL(OPUS_SIGNAL_MUSIC));
opus_custom_encoder_ctl(oe, OPUS_SET_SIGNAL(OPUS_APPLICATION_RESTRICTED_LOWDELAY));
opus_custom_encoder_init(oe, opus_mode, 1);
playback_srcs = jack_slist_append(playback_srcs, oe);
#endif
} else {
#if HAVE_SAMPLERATE
playback_srcs = jack_slist_append (playback_srcs, src_new (SRC_LINEAR, 1, NULL));
#endif
}
playback_ports = jack_slist_append (playback_ports, port);
}
/* Allocate midi playback channels */
for (chn = n_playback_audio; chn < n_playback_midi + n_playback_audio; chn++) {
snprintf (buf, sizeof (buf) - 1, "playback_%u", chn + 1);
port = jack_port_register (client, buf, JACK_DEFAULT_MIDI_TYPE, port_flags, 0);
if (!port) {
printf ("jack_netsource: cannot register %s port\n", buf);
break;
}
playback_ports = jack_slist_append (playback_ports, port);
}
}
static int
coreaudio_driver_attach(coreaudio_driver_t * driver, jack_engine_t * engine)
{
jack_port_t *port;
JSList *node;
int port_flags;
channel_t chn;
char buf[JACK_PORT_NAME_SIZE];
char channel_name[64];
OSStatus err;
UInt32 size;
UInt32 value1,value2;
Boolean isWritable;
jack_latency_range_t range;
driver->engine = engine;
if (driver->engine->set_buffer_size(engine, driver->frames_per_cycle)) {
jack_error ("coreaudio: cannot set engine buffer size to %d (check MIDI)", driver->frames_per_cycle);
return -1;
}
driver->engine->set_sample_rate(engine, driver->frame_rate);
port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;
/*
if (driver->has_hw_monitoring) {
port_flags |= JackPortCanMonitor;
}
*/
for (chn = 0; chn < driver->capture_nchannels; chn++) {
err = AudioDeviceGetPropertyInfo(driver->device_id, chn + 1, true, kAudioDevicePropertyChannelName, &size, &isWritable);
if (err == noErr && size > 0) {
err = AudioDeviceGetProperty(driver->device_id, chn + 1, true, kAudioDevicePropertyChannelName, &size, channel_name);
if (err != noErr)
JCALog("AudioDeviceGetProperty kAudioDevicePropertyChannelName error \n");
snprintf(buf, sizeof(buf) - 1, "%s:out_%s%lu", driver->capture_driver_name, channel_name, chn + 1);
} else {
snprintf(buf, sizeof(buf) - 1, "%s:out%lu", driver->capture_driver_name, chn + 1);
}
if ((port = jack_port_register(driver->client, buf,
JACK_DEFAULT_AUDIO_TYPE, port_flags,
0)) == NULL) {
jack_error("coreaudio: cannot register port for %s", buf);
break;
}
size = sizeof(UInt32);
value1 = value2 = 0;
err = AudioDeviceGetProperty(driver->device_id, 0, true, kAudioDevicePropertyLatency, &size, &value1);
if (err != noErr)
JCALog("AudioDeviceGetProperty kAudioDevicePropertyLatency error \n");
err = AudioDeviceGetProperty(driver->device_id, 0, true, kAudioDevicePropertySafetyOffset, &size, &value2);
if (err != noErr)
JCALog("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error \n");
range.min = range.max = driver->frames_per_cycle + value1 + value2 + driver->capture_frame_latency;
jack_port_set_latency_range(port, JackCaptureLatency, &range);
driver->capture_ports =
jack_slist_append(driver->capture_ports, port);
}
port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;
for (chn = 0; chn < driver->playback_nchannels; chn++) {
err = AudioDeviceGetPropertyInfo(driver->device_id, chn + 1, false, kAudioDevicePropertyChannelName, &size, &isWritable);
if (err == noErr && size > 0) {
err = AudioDeviceGetProperty(driver->device_id, chn + 1, false, kAudioDevicePropertyChannelName, &size, channel_name);
if (err != noErr)
JCALog("AudioDeviceGetProperty kAudioDevicePropertyChannelName error \n");
snprintf(buf, sizeof(buf) - 1, "%s:in_%s%lu", driver->playback_driver_name, channel_name, chn + 1);
} else {
snprintf(buf, sizeof(buf) - 1, "%s:in%lu", driver->playback_driver_name, chn + 1);
}
if ((port = jack_port_register(driver->client, buf,
JACK_DEFAULT_AUDIO_TYPE, port_flags,
0)) == NULL) {
jack_error("coreaudio: cannot register port for %s", buf);
break;
}
size = sizeof(UInt32);
value1 = value2 = 0;
err = AudioDeviceGetProperty(driver->device_id, 0, false, kAudioDevicePropertyLatency, &size, &value1);
if (err != noErr)
JCALog("AudioDeviceGetProperty kAudioDevicePropertyLatency error \n");
err = AudioDeviceGetProperty(driver->device_id, 0, false, kAudioDevicePropertySafetyOffset, &size, &value2);
if (err != noErr)
JCALog("AudioDeviceGetProperty kAudioDevicePropertySafetyOffset error \n");
range.min = range.max = driver->frames_per_cycle + value1 + value2 + driver->playback_frame_latency;
jack_port_set_latency_range(port, JackCaptureLatency, &range);
driver->playback_ports =
jack_slist_append(driver->playback_ports, port);
}
// Input buffers do no change : prepare them only once
for (chn = 0, node = driver->capture_ports; chn < driver->capture_nchannels; chn++, node = jack_slist_next(node)) {
driver->input_list->mBuffers[chn].mData
= (jack_default_audio_sample_t*)jack_port_get_buffer(((jack_port_t *) node->data), driver->frames_per_cycle);
}
jack_activate(driver->client);
return 0;
}
