jackspa.c

   1 /* jackspa.c - LADSPA plugin instance with JACK audio ports
   2  * Copyright © 2007 Nick Thomas
   3  * Copyright © 2013 Géraud Meyer <graud@gmx.com>
   4  *
   5  * This file is part of ng-jackspa.
   6  *
   7  * ng-jackpsa is free software; you can redistribute it and/or modify it under
   8  * the terms of the GNU General Public License version 2 as published by the
   9  * Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  14  * more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with ng-jackspa.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <dlfcn.h>
  21 #include <errno.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include "jackspa.h"
  26 #include "interface.h"
  27
  28 #include "ladspa.c"
  29
  30
  31 /* Initial config (command line) */
  32 static gboolean jackexactname = FALSE;
  33 static gboolean jacknostartserver = FALSE;
  34 static gchar *jackclientname = NULL;
  35 static gchar **portnames = NULL;
  36 gboolean parse_names(const gchar *opt, const gchar *arg,
  37                      gpointer data, GError **error)
  38 {
  39         g_strfreev(portnames); /* discard a possible previous option */
  40         portnames = g_strsplit(arg, ":", -1);
  41         return TRUE;
  42 }
  43 static gboolean controlvout = FALSE;
  44 static gint controlvin = 0;
  45 gboolean parse_cvio(const gchar *opt, const gchar *arg,
  46                    gpointer data, GError **error)
  47 {
  48         controlvin = 2;
  49         return TRUE;
  50 }
  51 const GOptionEntry jackspa_entries[] =
  52   {
  53     /* long, short, flags, arg_type, arg_data, description, arg_description */
  54     { "jack-exactname", 'N', 0, G_OPTION_ARG_NONE, &jackexactname,
  55       "Do not allow JACK to generate an unused client name", NULL },
  56     { "jack-nostartserver", 'S', 0, G_OPTION_ARG_NONE, &jacknostartserver,
  57       "Do not start a JACK server if none is running", NULL },
  58     { "jack-client", 'j', 0, G_OPTION_ARG_STRING, &jackclientname,
  59       "Use the given name instead of the concatenation of a fixed prefix and the plugin label", "client_name" },
  60     { "names", 'n', 0, G_OPTION_ARG_CALLBACK, parse_names,
  61       "Colon separated list of overriding names for the LADPSA audio and control ports", "port_names" },
  62     { "controlv-out", 'O', 0, G_OPTION_ARG_NONE, &controlvout,
  63       "Export the control outputs as control voltages on JACK audio ports", NULL },
  64     { "controlv-in", 'I', 0, G_OPTION_ARG_NONE, &controlvin,
  65       "Export the control inputs as control voltages on JACK input audio ports", NULL },
  66     { "controlv-inasout", 'T', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, parse_cvio,
  67       "Export the control inputs as control voltages on JACK output audio ports not on input ones", NULL },
  68     { 0 }
  69   };
  70 static char *ladspa_library = NULL;
  71 typedef struct {
  72         char is_label;
  73         union { unsigned long uid; char *label; } id;
  74 } plugin_id_t;
  75 static plugin_id_t ladspa_id = { 0 };
  76
  77
  78 /* Finds the plugin descriptor with the given ID in the given object file,
  79  * storing it in state->descriptor. Returns 1 on success. On failure, returns 0
  80  * and sets *error to an appropriate error message.
  81  */
  82 int find_plugin(state_t *state, const char *file, const plugin_id_t plugin_id,
  83                 const char **error)
  84 {
  85         int err = 0;
  86         unsigned long i; /* port index */
  87         LADSPA_Descriptor *(*descriptor_fun)(unsigned long index);
  88         LADSPA_Descriptor *descriptor;
  89
  90         /* Open the library. */
  91         state->library = ladspa_dlopen(file, RTLD_LAZY);
  92         if (!state->library)
  93                 err = 1, *error = dlerror();
  94
  95         /* Find the ladspa_descriptor() function. */
  96         if (!err) {
  97                 descriptor_fun = (LADSPA_Descriptor *(*)(unsigned long))
  98                   dlsym(state->library, "ladspa_descriptor");
  99                 if (!descriptor_fun)
 100                         err = 1, *error = dlerror();
 101         }
 102
 103         /* Find the appropriate descriptor. */
 104         for (i = 0; !err; i++) {
 105                 descriptor = descriptor_fun(i);
 106
 107                 if (!descriptor)
 108                         err = 1, *error = plugin_id.is_label ?
 109                           "no such plugin label in the given library" :
 110                           "no such plugin UID in the given library";
 111                 else if ( (!plugin_id.is_label && descriptor->UniqueID == plugin_id.id.uid) ||
 112                           (plugin_id.is_label && !strcmp(descriptor->Label, plugin_id.id.label)) )
 113                 {
 114                         state->descriptor = descriptor;
 115                         break;
 116                 }
 117         }
 118
 119         return !err;
 120 }
 121
 122 int close_plugin(state_t *state, const char **error)
 123 {
 124         state->descriptor = NULL;
 125
 126         if (dlclose(state->library))
 127                 return (*error = dlerror(), 0);
 128         state->library = NULL;
 129
 130         return 1;
 131 }
 132
 133 /* The JACK processing callback. */
 134 int process(jack_nframes_t nframes, void *arg)
 135 {
 136         state_t *state = (state_t *)arg;
 137         unsigned long p; /* loop variable for ports */
 138         const LADSPA_PortDescriptor *port; /* loop variable for port descriptors */
 139         void *buffer; /* JACK buffer */
 140         LADSPA_Data buf; /* buffer for the control outputs */
 141
 142         /* Connect audio ports and unused control ports */
 143         for ( p = 0, port = state->descriptor->PortDescriptors;
 144               p < state->descriptor->PortCount; p++, port++ )
 145         {
 146                 if (LADSPA_IS_PORT_CONTROL(*port)) {
 147                         if (LADSPA_IS_PORT_INPUT(*port) && !controlvin)
 148                                 continue;
 149                         if (LADSPA_IS_PORT_OUTPUT(*port) && !controlvout) {
 150                                 state->descriptor->connect_port(state->handle, p, &buf);
 151                                   /* forget the control output ports values */
 152                                 continue;
 153                         }
 154                 }
 155
 156                 buffer = jack_port_get_buffer(state->jack_ports[p], nframes);
 157                 if (LADSPA_IS_PORT_CONTROL(*port)) {
 158                         if (LADSPA_IS_PORT_OUTPUT(*port))
 159                                 memset(buffer, 0, (size_t)nframes); /* might be needless */
 160                                   /* only the first sample will be set */
 161                         else if (controlvin == 1 && !jack_port_connected(state->jack_ports[p]))
 162                                 *(LADSPA_Data *)buffer = state->control_port_values[p];
 163                                   /* use the previous value (or the value set in the UI) */
 164                         else if (controlvin == 1)
 165                                 state->control_port_values[p] = *(LADSPA_Data *)buffer;
 166                                   /* record the new control value */
 167                         else {
 168                                 memset(buffer, 0, (size_t)nframes); /* might be needless */
 169                                 *(LADSPA_Data *)buffer = state->control_port_values[p];
 170                         }
 171                 }
 172                 state->descriptor->connect_port
 173                   (state->handle, p, (LADSPA_Data *)buffer);
 174         }
 175
 176         /* Run the plugin. */
 177         state->descriptor->run(state->handle, nframes);
 178
 179         return 0;
 180 }
 181
 182 /* Initializes JACK, opening the appropriate ports, instantiating the LADSPA
 183  * Plugin, and starting the synthesis thread running.. Returns 1 on success. On
 184  * failure, returns 0 and sets *error to an appropriate error message.
 185  */
 186 int init_jack(state_t *state, const char **error)
 187 {
 188         static char client_name_prefix[] = "jackspa_";
 189         int err = 0;
 190         jack_options_t oflags;
 191         jack_status_t jack_status;
 192         unsigned long p; /* loop variable for ports */
 193         const LADSPA_PortDescriptor *port; /* loop variable for port descriptors */
 194         enum JackPortFlags pflags;
 195
 196         /* Allocate memory for the client name. */
 197         if (!jackclientname) {
 198                 state->client_name = (char *)calloc
 199                   ( sizeof(client_name_prefix) + strlen(state->descriptor->Label),
 200                     sizeof(char) );
 201                 if (!state->client_name)
 202                         err = 1, *error = strerror(errno);
 203         }
 204
 205         /* Set the client name. */
 206         if (!err) {
 207                 if (jackclientname)
 208                         state->client_name = jackclientname;
 209                 else {
 210                         /* state->client_name[0] = '\0'; */ /* done by calloc */
 211                         strcat(state->client_name, client_name_prefix);
 212                         strcat(state->client_name, state->descriptor->Label);
 213                 }
 214         }
 215
 216         /* Open JACK. */
 217         if (!err) {
 218                 oflags = JackNullOption;
 219                 if (jackexactname) oflags |= JackUseExactName;
 220                 if (jacknostartserver) oflags |= JackNoStartServer;
 221                 state->jack_client =
 222                   jack_client_open(state->client_name, oflags, &jack_status);
 223                 if (!state->jack_client)
 224                         err = 1, *error = "could not connect to JACK";
 225         }
 226
 227         /* Free memory for the client name */
 228         if (!jackclientname) free(state->client_name);
 229         if (!err) state->client_name = jack_get_client_name(state->jack_client);
 230
 231         /* Allocate memory for the list of ports. */
 232         if (!err) {
 233                 state->jack_ports = (jack_port_t **)calloc
 234                   (state->descriptor->PortCount, sizeof(jack_port_t *));
 235                 if (!state->jack_ports)
 236                         err = 1, *error = strerror(errno);
 237         }
 238
 239         /* Allocate memory for the list of control port values. */
 240         if (!err) {
 241                 state->control_port_values = (LADSPA_Data *)calloc
 242                   ((size_t)state->descriptor->PortCount, sizeof(LADSPA_Data));
 243                 if (!state->control_port_values)
 244                         err = 1, *error = strerror(errno);
 245         }
 246
 247         /* Register ports. */
 248         state->num_control_ports = 0; state->num_meter_ports = 0;
 249         for ( p = 0, port = state->descriptor->PortDescriptors;
 250               !err && p < state->descriptor->PortCount; p++, port++ )
 251         {
 252                 /* Get the actual port name */
 253                 state->port_names[p] = glib_strv_index(p, portnames);
 254                 if (!state->port_names[p] || *state->port_names[p] == '\0')
 255                         state->port_names[p] = state->descriptor->PortNames[p];
 256
 257                 /* Count control ports and skip non exported ports */
 258                 if (LADSPA_IS_PORT_CONTROL(*port)) {
 259                         if (LADSPA_IS_PORT_INPUT(*port)) {
 260                                 state->num_control_ports++;
 261                                 if (!controlvin) continue;
 262                         }
 263                         else {
 264                                 state->num_meter_ports++;
 265                                 if (!controlvout) continue;
 266                         }
 267                 }
 268
 269                 if (LADSPA_IS_PORT_INPUT(*port)) {
 270                         if (controlvin != 1 && LADSPA_IS_PORT_CONTROL(*port))
 271                                 pflags = JackPortIsOutput;
 272                         else
 273                                 pflags = JackPortIsInput;
 274                 }
 275                 else
 276                         pflags = JackPortIsOutput;
 277
 278                 state->jack_ports[p] = jack_port_register
 279                   ( state->jack_client, state->port_names[p],
 280                     JACK_DEFAULT_AUDIO_TYPE, pflags, 0 );
 281
 282                 if (!state->jack_ports[p])
 283                         err = 1, *error = "could not register JACK ports";
 284         }
 285
 286         /* Register our processing callback. */
 287         if (!err)
 288                 if (jack_set_process_callback(state->jack_client, &process, state))
 289                         err = 1, *error = "could not register the JACK processing callback";
 290
 291         /* Instantiate the LADSPA plugin. */
 292         if (!err) {
 293                 state->handle = state->descriptor->instantiate
 294                   (state->descriptor, jack_get_sample_rate(state->jack_client));
 295                 if (!state->handle)
 296                         err = 1, *error = "could not instantiate the plugin.";
 297         }
 298
 299         /* Connect input control ports. */
 300         if (!err)
 301                 for (p = 0; p < state->descriptor->PortCount; p++)
 302                         if ( LADSPA_IS_PORT_CONTROL(state->descriptor->PortDescriptors[p]) &&
 303                              LADSPA_IS_PORT_INPUT(state->descriptor->PortDescriptors[p]))
 304                         {
 305                                 state->descriptor->connect_port
 306                                   (state->handle, p, &state->control_port_values[p]);
 307                                 /* state->control_port_values[p] = 0.0; */ /* done by calloc() */
 308                         }
 309
 310         /* Activate the LADSPA plugin. */
 311         if (!err)
 312                 if (state->descriptor->activate)
 313                         state->descriptor->activate(state->handle);
 314
 315         /* Get the bits flowing. */
 316         if (!err)
 317                 if (jack_activate(state->jack_client))
 318                         err = 1, *error = "could not activate audio processing";
 319
 320         return !err;
 321 }
 322
 323 typedef enum {
 324         st_want_plugin_file,
 325         st_want_plugin_id,
 326         st_done
 327 } arg_parser_state;
 328
 329 /* Parses command-line arguments. Returns 1 on success. On failure, returns 0
 330  * and sets *error to an appropriate error message.
 331  */
 332 int parse_args(state_t *state, int argc, char **argv, char **plugin_file,
 333                plugin_id_t *plugin_id, const char **error)
 334 {
 335         int err = 0;
 336         int i; /* arg index */
 337         arg_parser_state st = st_want_plugin_file;
 338         char *e;
 339
 340         argc--, argv++; /* skip the program name */
 341
 342         for (i = 0; i < argc; i++)
 343                 switch (st) {
 344                 case st_want_plugin_file:
 345                         *plugin_file = argv[i];
 346                         st = st_want_plugin_id;
 347                         break;
 348
 349                 case st_want_plugin_id:
 350                         plugin_id->is_label = 0, plugin_id->id.uid = strtol(argv[i], &e, 0);
 351                         if (e == argv[i] || *e != '\0')
 352                                 plugin_id->is_label = 1, plugin_id->id.label = argv[i];
 353                         st = st_done;
 354                         break;
 355
 356                 case st_done:
 357                 default:
 358                         err = 1, *error = "extra arguments given";
 359                         break;
 360                 }
 361
 362         if (st != st_done)
 363                 err = 1, *error = "must supply a plugin file and a plugin ID";
 364
 365         return !err;
 366 }
 367
 368 int jackspa_init(state_t *state, int argc, char **argv)
 369 {
 370         const char *error;
 371         int err = 0;
 372
 373         state->jack_client = 0;
 374
 375         err = !parse_args(state, argc, argv, &ladspa_library, &ladspa_id, &error);
 376
 377         if (!err)
 378                 err = !find_plugin(state, ladspa_library, ladspa_id, &error);
 379
 380         if (!err) {
 381                 state->port_names =
 382                   (const char **)calloc(state->descriptor->PortCount, sizeof(char *));
 383                 if (!state->port_names)
 384                         err = 1, error = "memory allocation error";
 385         }
 386
 387         if (!err)
 388                 err = !init_jack(state, &error);
 389
 390         if (err)
 391                 fprintf(stderr, "jackspa error: %s\n", error);
 392
 393         return !err;
 394 }
 395
 396 int jackspa_fini(state_t *state)
 397 {
 398         int err = 0;
 399         const char *error;
 400
 401         if ((err = jack_client_close(state->jack_client)))
 402                 return !err;
 403         state->jack_client = 0;
 404
 405         if (state->descriptor->deactivate)
 406                 state->descriptor->deactivate(state->handle);
 407         state->descriptor->cleanup(state->handle);
 408         state->handle = 0;
 409
 410         free(state->control_port_values), state->control_port_values = NULL;
 411         free(state->jack_ports), state->jack_ports = NULL;
 412         state->num_control_ports = 0; state->num_meter_ports = 0;
 413
 414         free(state->port_names);
 415
 416         err = !close_plugin(state, &error);
 417
 418         return !err;
 419 }