libaf/af_ladspa.c

   1 /*
   2  * LADSPA plugin loader
   3  *
   4  * Written by Ivo van Poorten <ivop@euronet.nl>
   5  * Copyright (C) 2004, 2005
   6  *
   7  * This file is part of MPlayer.
   8  *
   9  * MPlayer is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * MPlayer is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License along
  20  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
  21  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  22  */
  23
  24 /* ------------------------------------------------------------------------- */
  25
  26 /* Global Includes */
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31
  32 #include <inttypes.h>
  33 #include <math.h>
  34 #include <limits.h>
  35
  36 #include <dlfcn.h>
  37 #include <ladspa.h>
  38
  39 /* ------------------------------------------------------------------------- */
  40
  41 /* Local Includes */
  42
  43 #include "af.h"
  44
  45 /* ------------------------------------------------------------------------- */
  46
  47 /* Filter specific data */
  48
  49 typedef struct af_ladspa_s
  50 {
  51     int status;     /**< Status of the filter.
  52                      *   Either AF_OK or AF_ERROR
  53                      *   Because MPlayer re-inits audio filters that
  54                      *   _clearly_ returned AF_ERROR anyway, I use this
  55                      *   in play() to skip the processing and return
  56                      *   the data unchanged.
  57                      */
  58
  59     int activated;  /**< 0 or 1. Activate LADSPA filters only once, even
  60                      *   if the buffers get resized, to avoid a stuttering
  61                      *   filter.
  62                      */
  63
  64     char *file;
  65     char *label;
  66
  67     char *myname;   /**< It's easy to have a concatenation of file and label */
  68
  69     void *libhandle;
  70     const LADSPA_Descriptor *plugin_descriptor;
  71
  72     int nports;
  73
  74     int ninputs;
  75     int *inputs;
  76
  77     int noutputs;
  78     int *outputs;
  79
  80     int ninputcontrols;
  81     int *inputcontrolsmap;  /**< Map input port number [0-] to actual port */
  82     float *inputcontrols;
  83
  84     int noutputcontrols;
  85     int *outputcontrolsmap;
  86     float *outputcontrols;
  87
  88     int nch;                /**< number of channels */
  89     int bufsize;
  90     float **inbufs;
  91     float **outbufs;
  92     LADSPA_Handle *chhandles;
  93
  94 } af_ladspa_t;
  95
  96 /* ------------------------------------------------------------------------- */
  97
  98 static int af_open(af_instance_t *af);
  99 static int af_ladspa_malloc_failed(char*);
 100
 101 /* ------------------------------------------------------------------------- */
 102
 103 /* Description */
 104
 105 af_info_t af_info_ladspa = {
 106     "LADSPA plugin loader",
 107     "ladspa",
 108     "Ivo van Poorten",
 109     "",
 110     AF_FLAGS_REENTRANT,
 111     af_open
 112 };
 113
 114 /* ------------------------------------------------------------------------- */
 115
 116 /* By lack of a better word (in my vocabulary) this is called 'parse'.
 117  * Feel free to suggest an alternative.
 118  */
 119
 120 /** \brief Check for inputs, outputs and controls of a given filter.
 121  *
 122  * This function counts and checks all input, output and control ports
 123  * of the filter that was loaded. If it turns out to be a valid
 124  * filter for MPlayer use, it prints out a list of all controls and
 125  * the corresponding range of its value at message level  MSGL_V.
 126  *
 127  * \param setup     Current setup of the filter. Must have its
 128  *                  plugin_descriptor set!
 129  *
 130  * \return  Returns AF_OK if it has a valid input/output/controls
 131  *          configuration. Else, it returns AF_ERROR.
 132  */
 133
 134 static int af_ladspa_parse_plugin(af_ladspa_t *setup) {
 135     int p, i;
 136     const LADSPA_Descriptor *pdes = setup->plugin_descriptor;
 137     LADSPA_PortDescriptor d;
 138     LADSPA_PortRangeHint hint;
 139
 140     if (!setup->libhandle)
 141         return AF_ERROR; /* only call parse after a succesful load */
 142     if (!setup->plugin_descriptor)
 143         return AF_ERROR; /* same as above */
 144
 145     /* let's do it */
 146
 147     setup->nports = pdes->PortCount;
 148
 149     /* allocate memory for all inputs/outputs/controls */
 150
 151     setup->inputs = calloc(setup->nports, sizeof(int));
 152     if (!setup->inputs) return af_ladspa_malloc_failed(setup->myname);
 153
 154     setup->outputs = calloc(setup->nports, sizeof(int));
 155     if (!setup->outputs) return af_ladspa_malloc_failed(setup->myname);
 156
 157     setup->inputcontrolsmap = calloc(setup->nports, sizeof(int));
 158     if (!setup->inputcontrolsmap) return af_ladspa_malloc_failed(setup->myname);
 159
 160     setup->inputcontrols = calloc(setup->nports, sizeof(float));
 161     if (!setup->inputcontrols) return af_ladspa_malloc_failed(setup->myname);
 162
 163     setup->outputcontrolsmap = calloc(setup->nports, sizeof(int));
 164     if (!setup->outputcontrolsmap) return af_ladspa_malloc_failed(setup->myname);
 165
 166     setup->outputcontrols = calloc(setup->nports, sizeof(float));
 167     if (!setup->outputcontrols) return af_ladspa_malloc_failed(setup->myname);
 168
 169     /* set counts to zero */
 170
 171     setup->ninputs = 0;
 172     setup->noutputs = 0;
 173     setup->ninputcontrols = 0;
 174     setup->noutputcontrols = 0;
 175
 176     /* check all ports, see what type it is and set variables according to
 177      * what we have found
 178      */
 179
 180     for (p=0; p<setup->nports; p++) {
 181         d = pdes->PortDescriptors[p];
 182
 183         if (LADSPA_IS_PORT_AUDIO(d)) {
 184             if (LADSPA_IS_PORT_INPUT(d)) {
 185                 setup->inputs[setup->ninputs] = p;
 186                 setup->ninputs++;
 187             } else if (LADSPA_IS_PORT_OUTPUT(d)) {
 188                 setup->outputs[setup->noutputs] = p;
 189                 setup->noutputs++;
 190             }
 191         }
 192
 193         if (LADSPA_IS_PORT_CONTROL(d)) {
 194             if (LADSPA_IS_PORT_INPUT(d)) {
 195                 setup->inputcontrolsmap[setup->ninputcontrols] = p;
 196                 setup->ninputcontrols++;
 197                 /* set control to zero. set values after reading the rest
 198                  * of the suboptions and check LADSPA_?_HINT's later.
 199                  */
 200                 setup->inputcontrols[p] = 0.0f;
 201             } else if (LADSPA_IS_PORT_OUTPUT(d)) {
 202                 /* read and handle these too, otherwise filters that have them
 203                  * will sig11
 204                  */
 205                 setup->outputcontrolsmap[setup->noutputcontrols]=p;
 206                 setup->noutputcontrols++;
 207                 setup->outputcontrols[p] = 0.0f;
 208             }
 209         }
 210
 211     }
 212
 213     if (setup->ninputs == 0) {
 214         mp_msg(MSGT_AFILTER, MSGL_WARN, "%s: %s\n", setup->myname,
 215                                                 _("WARNING! This LADSPA plugin has no audio inputs.\n  The incoming audio signal will be lost."));
 216     } else if (setup->ninputs == 1) {
 217         mp_msg(MSGT_AFILTER, MSGL_V, "%s: this is a mono effect\n", setup->myname);
 218     } else if (setup->ninputs == 2) {
 219         mp_msg(MSGT_AFILTER, MSGL_V, "%s: this is a stereo effect\n", setup->myname);
 220     } else {
 221         mp_msg(MSGT_AFILTER, MSGL_V, "%s: this is a %i-channel effect, "
 222                "support is experimental\n", setup->myname, setup->ninputs);
 223     }
 224
 225     if (setup->noutputs == 0) {
 226         mp_msg(MSGT_AFILTER, MSGL_ERR, "%s: %s\n", setup->myname,
 227                                                 _("This LADSPA plugin has no audio outputs."));
 228         return AF_ERROR;
 229     }
 230
 231     if (setup->noutputs != setup->ninputs ) {
 232         mp_msg(MSGT_AFILTER, MSGL_ERR, "%s: %s\n", setup->myname,
 233                                                 _("The number of audio inputs and audio outputs of the LADSPA plugin differ."));
 234         return AF_ERROR;
 235     }
 236
 237     mp_msg(MSGT_AFILTER, MSGL_V, "%s: this plugin has %d input control(s)\n",
 238                                         setup->myname, setup->ninputcontrols);
 239
 240     /* Print list of controls and its range of values it accepts */
 241
 242     for (i=0; i<setup->ninputcontrols; i++) {
 243         p = setup->inputcontrolsmap[i];
 244         hint = pdes->PortRangeHints[p];
 245         mp_msg(MSGT_AFILTER, MSGL_V, "  --- %d %s [", i, pdes->PortNames[p]);
 246
 247         if (LADSPA_IS_HINT_BOUNDED_BELOW(hint.HintDescriptor)) {
 248             mp_msg(MSGT_AFILTER, MSGL_V, "%0.2f , ", hint.LowerBound);
 249         } else {
 250             mp_msg(MSGT_AFILTER, MSGL_V, "... , ");
 251         }
 252
 253         if (LADSPA_IS_HINT_BOUNDED_ABOVE(hint.HintDescriptor)) {
 254             mp_msg(MSGT_AFILTER, MSGL_V, "%0.2f]\n", hint.UpperBound);
 255         } else {
 256             mp_msg(MSGT_AFILTER, MSGL_V, "...]\n");
 257         }
 258
 259     }
 260
 261     return AF_OK;
 262 }
 263
 264 /* ------------------------------------------------------------------------- */
 265
 266 /* This function might "slightly" look like dlopenLADSPA in the LADSPA SDK :-)
 267  * But, I changed a few things, because imho it was broken. It did not support
 268  * relative paths, only absolute paths that start with a /
 269  * I think ../../some/dir/foobar.so is just as valid. And if one wants to call
 270  * his library '...somename...so' he's crazy, but it should be allowed.
 271  * So, search the path first, try plain *filename later.
 272  * Also, try adding .so first! I like the recursion the SDK did, but it's
 273  * better the other way around. -af ladspa=cmt:amp_stereo:0.5 is easier to type
 274  * than -af ladspa=cmt.so:amp_stereo:0.5 :-))
 275  */
 276
 277 /** \brief dlopen() wrapper
 278  *
 279  * This is a wrapper around dlopen(). It tries various variations of the
 280  * filename (with or without the addition of the .so extension) in various
 281  * directories specified by the LADSPA_PATH environment variable. If all fails
 282  * it tries the filename directly as an absolute path to the library.
 283  *
 284  * \param filename  filename of the library to load.
 285  * \param flag      see dlopen(3) for a description of the flags.
 286  *
 287  * \return          returns a pointer to the loaded library on success, or
 288  *                  NULL if it fails to load.
 289  */
 290
 291 static void* mydlopen(const char *filename, int flag) {
 292     char *buf;
 293     const char *end, *start, *ladspapath;
 294     int endsinso, needslash;
 295     size_t filenamelen;
 296     void *result = NULL;
 297
 298 #if defined(__MINGW32__) || defined(__CYGWIN__)
 299     /* For Windows there's only absolute path support.
 300      * If you have a Windows machine, feel free to fix this.
 301      * (path separator, shared objects extension, et cetera). */
 302         mp_msg(MSGT_AFILTER, MSGL_V, "\ton windows, only absolute pathnames "
 303                 "are supported\n");
 304         mp_msg(MSGT_AFILTER, MSGL_V, "\ttrying %s\n", filename);
 305         return dlopen(filename, flag);
 306 #endif
 307
 308     filenamelen = strlen(filename);
 309
 310     endsinso = 0;
 311     if (filenamelen > 3)
 312         endsinso = (strcmp(filename+filenamelen-3, ".so") == 0);
 313     if (!endsinso) {
 314         buf=malloc(filenamelen+4);
 315         strcpy(buf, filename);
 316         strcat(buf, ".so");
 317         result=mydlopen(buf, flag);
 318         free(buf);
 319     }
 320
 321     if (result)
 322         return result;
 323
 324     ladspapath=getenv("LADSPA_PATH");
 325
 326     if (ladspapath) {
 327
 328         start=ladspapath;
 329         while (*start != '\0') {
 330             end=start;
 331             while ( (*end != ':') && (*end != '\0') )
 332                 end++;
 333
 334             buf=malloc(filenamelen + 2 + (end-start) );
 335             if (end > start)
 336                 strncpy(buf, start, end-start);
 337             needslash=0;
 338             if (end > start)
 339                 if (*(end-1) != '/') {
 340                     needslash = 1;
 341                     buf[end-start] = '/';
 342                 }
 343             strcpy(buf+needslash+(end-start), filename);
 344
 345             mp_msg(MSGT_AFILTER, MSGL_V, "\ttrying %s\n", buf);
 346             result=dlopen(buf, flag);
 347
 348             free(buf);
 349             if (result)
 350                 return result;
 351
 352             start = end;
 353             if (*start == ':')
 354                 start++;
 355         } /* end while there's still more in the path */
 356     } /* end if there's a ladspapath */
 357
 358     /* last resort, just open it again, so the dlerror() message is correct */
 359     mp_msg(MSGT_AFILTER, MSGL_V, "\ttrying %s\n", filename);
 360     return dlopen(filename,flag);
 361 }
 362
 363 /* ------------------------------------------------------------------------- */
 364
 365 /** \brief Load a LADSPA Plugin
 366  *
 367  * This function loads the LADSPA plugin specified by the file and label
 368  * that are present in the setup variable. First, it loads the library.
 369  * If it fails, it returns AF_ERROR. If not, it continues to look for the
 370  * specified label. If it finds it, it sets the plugin_descriptor inside
 371  * setup and returns AF_OK. If it doesn't, it returns AF_ERROR. Special case
 372  * is a label called 'help'. In that case, it prints a list of all available
 373  * labels (filters) in the library specified by file.
 374  *
 375  * \param setup     Current setup of the filter. Contains filename and label.
 376  *
 377  * \return  Either AF_ERROR or AF_OK, depending on the success of the operation.
 378  */
 379
 380 static int af_ladspa_load_plugin(af_ladspa_t *setup) {
 381     const LADSPA_Descriptor *ladspa_descriptor;
 382     LADSPA_Descriptor_Function descriptor_function;
 383     int i;
 384
 385     /* load library */
 386     mp_msg(MSGT_AFILTER, MSGL_V, "%s: loading ladspa plugin library %s\n",
 387                                                 setup->myname, setup->file);
 388
 389     setup->libhandle = mydlopen(setup->file, RTLD_NOW);
 390
 391     if (!setup->libhandle) {
 392         mp_msg(MSGT_AFILTER, MSGL_ERR, "%s: %s %s\n\t%s\n", setup->myname,
 393                     _("failed to load"), setup->file, dlerror() );
 394         return AF_ERROR;
 395     }
 396
 397     mp_msg(MSGT_AFILTER, MSGL_V, "%s: library found.\n", setup->myname);
 398
 399     /* find descriptor function */
 400     dlerror();
 401     descriptor_function = (LADSPA_Descriptor_Function) dlsym (setup->libhandle,
 402                                                         "ladspa_descriptor");
 403
 404     if (!descriptor_function) {
 405         mp_msg(MSGT_AFILTER, MSGL_ERR, "%s: %s\n\t%s\n", setup->myname,
 406                                 _("Couldn't find ladspa_descriptor() function in the specified library file."), dlerror());
 407         return AF_ERROR;
 408     }
 409
 410     /* if label == help, list all labels in library and exit */
 411
 412     if (strcmp(setup->label, "help") == 0) {
 413         mp_msg(MSGT_AFILTER, MSGL_INFO, "%s: %s %s:\n", setup->myname,
 414                 _("available labels in"), setup->file);
 415         for (i=0; ; i++) {
 416             ladspa_descriptor = descriptor_function(i);
 417             if (ladspa_descriptor == NULL) {
 418                 return AF_ERROR;
 419             }
 420             mp_msg(MSGT_AFILTER, MSGL_INFO, "  %-16s - %s (%lu)\n",
 421                     ladspa_descriptor->Label,
 422                     ladspa_descriptor->Name,
 423                     ladspa_descriptor->UniqueID);
 424         }
 425     }
 426
 427     mp_msg(MSGT_AFILTER, MSGL_V, "%s: looking for label\n", setup->myname);
 428
 429     /* find label in library */
 430     for (i=0; ; i++) {
 431         ladspa_descriptor = descriptor_function(i);
 432         if (ladspa_descriptor == NULL) {
 433             mp_msg(MSGT_AFILTER, MSGL_ERR, "%s: %s\n", setup->myname,
 434                                             _("Couldn't find label in plugin library."));
 435             return AF_ERROR;
 436         }
 437         if (strcmp(ladspa_descriptor->Label, setup->label) == 0) {
 438             setup->plugin_descriptor = ladspa_descriptor;
 439             mp_msg(MSGT_AFILTER, MSGL_V, "%s: %s found\n", setup->myname,
 440                                                                 setup->label);
 441             return AF_OK;
 442         }
 443     }
 444
 445     return AF_OK;
 446 }
 447
 448 /* ------------------------------------------------------------------------- */
 449
 450 /** \brief Print a malloc() failed error message.
 451  *
 452  * Generic function which can be called if a call to malloc(), calloc(),
 453  * strdup(), et cetera, failed. It prints a message to the console and
 454  * returns AF_ERROR.
 455  *
 456  * \return  AF_ERROR
 457  */
 458
 459 static int af_ladspa_malloc_failed(char *myname) {
 460     mp_msg(MSGT_AFILTER, MSGL_ERR, "%s: %s", myname, "Memory allocation failed.\n");
 461     return AF_ERROR;
 462 }
 463
 464 /* ------------------------------------------------------------------------- */
 465
 466 /** \brief Controls the filter.
 467  *
 468  * Control the behaviour of the filter.
 469  *
 470  * Commands:
 471  * CONTROL_REINIT   Sets the af structure with proper values for number
 472  *                  of channels, rate, format, et cetera.
 473  * CONTROL_COMMAND_LINE     Parses the suboptions given to this filter
 474  *                          through arg. It first parses the filename and
 475  *                          the label. After that, it loads the filter
 476  *                          and finds out its proprties. Then in continues
 477  *                          parsing the controls given on the commandline,
 478  *                          if any are needed.
 479  *
 480  * \param af    Audio filter instance
 481  * \param cmd   The command to execute
 482  * \param arg   Arguments to the command
 483  *
 484  * \return      Either AF_ERROR or AF_OK, depending on the succes of the
 485  *              operation.
 486  */
 487
 488 static int control(struct af_instance_s *af, int cmd, void *arg) {
 489     af_ladspa_t *setup = (af_ladspa_t*) af->setup;
 490     int i, r;
 491     float val;
 492
 493     switch(cmd) {
 494     case AF_CONTROL_REINIT:
 495         mp_msg(MSGT_AFILTER, MSGL_V, "%s: (re)init\n", setup->myname);
 496
 497         if (!arg) return AF_ERROR;
 498
 499         /* accept FLOAT, let af_format do conversion */
 500
 501         af->data->rate   = ((af_data_t*)arg)->rate;
 502         af->data->nch    = ((af_data_t*)arg)->nch;
 503         af->data->format = AF_FORMAT_FLOAT_NE;
 504         af->data->bps    = 4;
 505
 506         /* arg->len is not set here yet, so init of buffers and connecting the
 507          * filter, has to be done in play() :-/
 508          */
 509
 510         return af_test_output(af, (af_data_t*)arg);
 511     case AF_CONTROL_COMMAND_LINE: {
 512         char *buf;
 513         char *line = arg;
 514
 515         mp_msg(MSGT_AFILTER, MSGL_V, "%s: parse suboptions\n", setup->myname);
 516
 517         /* suboption parser here!
 518          * format is (ladspa=)file:label:controls....
 519          */
 520
 521         if (!line) {
 522             mp_msg(MSGT_AFILTER, MSGL_ERR, "%s: %s\n", setup->myname,
 523                                             _("No suboptions specified."));
 524             return AF_ERROR;
 525         }
 526
 527         buf = malloc(strlen(line)+1);
 528         if (!buf) return af_ladspa_malloc_failed(setup->myname);
 529
 530         /* file... */
 531         buf[0] = '\0';
 532         sscanf(line, "%[^:]", buf);
 533         if (buf[0] == '\0') {
 534             mp_msg(MSGT_AFILTER, MSGL_ERR, "%s: %s\n", setup->myname,
 535                                                 _("No library file specified."));
 536             free(buf);
 537             return AF_ERROR;
 538         }
 539         line += strlen(buf);
 540         setup->file = strdup(buf);
 541         if (!setup->file) return af_ladspa_malloc_failed(setup->myname);
 542         mp_msg(MSGT_AFILTER, MSGL_V, "%s: file --> %s\n", setup->myname,
 543                                                         setup->file);
 544         if (*line != '\0') line++; /* read ':' */
 545
 546         /* label... */
 547         buf[0] = '\0';
 548         sscanf(line, "%[^:]", buf);
 549         if (buf[0] == '\0') {
 550             mp_msg(MSGT_AFILTER, MSGL_ERR, "%s: %s\n", setup->myname,
 551                                                 _("No filter label specified."));
 552             free(buf);
 553             return AF_ERROR;
 554         }
 555         line += strlen(buf);
 556         setup->label = strdup(buf);
 557         if (!setup->label) return af_ladspa_malloc_failed(setup->myname);
 558         mp_msg(MSGT_AFILTER, MSGL_V, "%s: label --> %s\n", setup->myname,
 559                                                                 setup->label);
 560 /*        if (*line != '0') line++; */ /* read ':' */
 561
 562         free(buf); /* no longer needed */
 563
 564         /* set new setup->myname */
 565
 566         free(setup->myname);
 567         setup->myname = calloc(strlen(af_info_ladspa.name)+strlen(setup->file)+
 568                                                     strlen(setup->label)+6, 1);
 569         snprintf(setup->myname, strlen(af_info_ladspa.name)+
 570                 strlen(setup->file)+strlen(setup->label)+6, "%s: (%s:%s)",
 571                             af_info_ladspa.name, setup->file, setup->label);
 572
 573         /* load plugin :) */
 574
 575         if ( af_ladspa_load_plugin(setup) != AF_OK )
 576             return AF_ERROR;
 577
 578         /* see what inputs, outputs and controls this plugin has */
 579         if ( af_ladspa_parse_plugin(setup) != AF_OK )
 580             return AF_ERROR;
 581
 582         /* ninputcontrols is set by now, read control values from arg */
 583
 584         for(i=0; i<setup->ninputcontrols; i++) {
 585             if (!line || *line != ':') {
 586                 mp_msg(MSGT_AFILTER, MSGL_ERR, "%s: %s\n", setup->myname,
 587                                         _("Not enough controls specified on the command line."));
 588                 return AF_ERROR;
 589             }
 590             line++;
 591             r = sscanf(line, "%f", &val);
 592             if (r!=1) {
 593                 mp_msg(MSGT_AFILTER, MSGL_ERR, "%s: %s\n", setup->myname,
 594                                         _("Not enough controls specified on the command line."));
 595                 return AF_ERROR;
 596             }
 597             setup->inputcontrols[setup->inputcontrolsmap[i]] = val;
 598             line = strchr(line, ':');
 599         }
 600
 601         mp_msg(MSGT_AFILTER, MSGL_V, "%s: input controls: ", setup->myname);
 602         for(i=0; i<setup->ninputcontrols; i++) {
 603             mp_msg(MSGT_AFILTER, MSGL_V, "%0.4f ",
 604                             setup->inputcontrols[setup->inputcontrolsmap[i]]);
 605         }
 606         mp_msg(MSGT_AFILTER, MSGL_V, "\n");
 607
 608         /* check boundaries of inputcontrols */
 609
 610         mp_msg(MSGT_AFILTER, MSGL_V, "%s: checking boundaries of input controls\n",
 611                                                                 setup->myname);
 612         for(i=0; i<setup->ninputcontrols; i++) {
 613             int p = setup->inputcontrolsmap[i];
 614             LADSPA_PortRangeHint hint =
 615                                 setup->plugin_descriptor->PortRangeHints[p];
 616             val = setup->inputcontrols[p];
 617
 618             if (LADSPA_IS_HINT_BOUNDED_BELOW(hint.HintDescriptor) &&
 619                     val < hint.LowerBound) {
 620                 mp_tmsg(MSGT_AFILTER, MSGL_ERR, "%s: Input control #%d is below lower boundary of %0.4f.\n",
 621                                             setup->myname, i, hint.LowerBound);
 622                 return AF_ERROR;
 623             }
 624             if (LADSPA_IS_HINT_BOUNDED_ABOVE(hint.HintDescriptor) &&
 625                     val > hint.UpperBound) {
 626                 mp_tmsg(MSGT_AFILTER, MSGL_ERR, "%s: Input control #%d is above upper boundary of %0.4f.\n",
 627                                             setup->myname, i, hint.UpperBound);
 628                 return AF_ERROR;
 629             }
 630         }
 631         mp_msg(MSGT_AFILTER, MSGL_V, "%s: all controls have sane values\n",
 632                                                                 setup->myname);
 633
 634         /* All is well! */
 635         setup->status = AF_OK;
 636
 637         return AF_OK; }
 638     }
 639
 640     return AF_UNKNOWN;
 641 }
 642
 643 /* ------------------------------------------------------------------------- */
 644
 645 /** \brief Uninitialise the LADSPA Plugin Loader filter.
 646  *
 647  * This function deactivates the plugin(s), cleans up, frees all allocated
 648  * memory and exits.
 649  *
 650  * \return  No return value.
 651  */
 652
 653 static void uninit(struct af_instance_s *af) {
 654     int i;
 655
 656     free(af->data);
 657     if (af->setup) {
 658         af_ladspa_t *setup = (af_ladspa_t*) af->setup;
 659         const LADSPA_Descriptor *pdes = setup->plugin_descriptor;
 660
 661         if (setup->myname) {
 662             mp_msg(MSGT_AFILTER, MSGL_V, "%s: cleaning up\n", setup->myname);
 663             free(setup->myname);
 664         }
 665
 666         if (setup->chhandles) {
 667             for(i=0; i<setup->nch; i+=setup->ninputs) {
 668                 if (pdes->deactivate) pdes->deactivate(setup->chhandles[i]);
 669                 if (pdes->cleanup) pdes->cleanup(setup->chhandles[i]);
 670             }
 671             free(setup->chhandles);
 672         }
 673
 674         free(setup->file);
 675         free(setup->label);
 676         free(setup->inputcontrolsmap);
 677         free(setup->inputcontrols);
 678         free(setup->outputcontrolsmap);
 679         free(setup->outputcontrols);
 680         free(setup->inputs);
 681         free(setup->outputs);
 682
 683         if (setup->inbufs) {
 684             for(i=0; i<setup->nch; i++)
 685                 free(setup->inbufs[i]);
 686             free(setup->inbufs);
 687         }
 688
 689         if (setup->outbufs) {
 690             for(i=0; i<setup->nch; i++)
 691                 free(setup->outbufs[i]);
 692             free(setup->outbufs);
 693         }
 694
 695         if (setup->libhandle)
 696             dlclose(setup->libhandle);
 697
 698         free(setup);
 699         setup = NULL;
 700     }
 701 }
 702
 703 /* ------------------------------------------------------------------------- */
 704
 705 /** \brief Process chunk of audio data through the selected LADSPA Plugin.
 706  *
 707  * \param af    Pointer to audio filter instance
 708  * \param data  Pointer to chunk of audio data
 709  *
 710  * \return      Either AF_ERROR or AF_OK
 711  */
 712
 713 static af_data_t* play(struct af_instance_s *af, af_data_t *data) {
 714     af_ladspa_t *setup = af->setup;
 715     const LADSPA_Descriptor *pdes = setup->plugin_descriptor;
 716     float *audio = (float*)data->audio;
 717     int nsamples = data->len/4; /* /4 because it's 32-bit float */
 718     int nch = data->nch;
 719     int rate = data->rate;
 720     int i, p;
 721
 722     if (setup->status !=AF_OK)
 723         return data;
 724
 725     /* See if it's the first call. If so, setup inbufs/outbufs, instantiate
 726      * plugin, connect ports and activate plugin
 727      */
 728
 729     /* 2004-12-07: Also check if the buffersize has to be changed!
 730      *             data->len is not constant per se! re-init buffers.
 731      */
 732
 733     if ( (setup->bufsize != nsamples/nch) || (setup->nch != nch) ) {
 734
 735         /* if setup->nch==0, it's the first call, if not, something has
 736          * changed and all previous mallocs have to be freed
 737          */
 738
 739         if (setup->nch != 0) {
 740             mp_msg(MSGT_AFILTER, MSGL_DBG3, "%s: bufsize change; free old buffer\n",
 741                                                                 setup->myname);
 742
 743             if(setup->inbufs) {
 744                 for(i=0; i<setup->nch; i++)
 745                     free(setup->inbufs[i]);
 746                 free(setup->inbufs);
 747             }
 748             if(setup->outbufs) {
 749                 for(i=0; i<setup->nch; i++)
 750                     free(setup->outbufs[i]);
 751                 free(setup->outbufs);
 752             }
 753         } /* everything is freed */
 754
 755         setup->bufsize = nsamples/nch;
 756         setup->nch = nch;
 757
 758         setup->inbufs = calloc(nch, sizeof(float*));
 759         setup->outbufs = calloc(nch, sizeof(float*));
 760
 761         mp_msg(MSGT_AFILTER, MSGL_DBG3, "%s: bufsize = %d\n",
 762                                         setup->myname, setup->bufsize);
 763
 764         for(i=0; i<nch; i++) {
 765             setup->inbufs[i] = calloc(setup->bufsize, sizeof(float));
 766             setup->outbufs[i] = calloc(setup->bufsize, sizeof(float));
 767         }
 768
 769         /* only on the first call, there are no handles. */
 770
 771         if (!setup->chhandles) {
 772             setup->chhandles = calloc(nch, sizeof(LADSPA_Handle));
 773
 774             /* create handles
 775              * for stereo effects, create one handle for two channels
 776              */
 777
 778             for(i=0; i<nch; i++) {
 779
 780                 if (i % setup->ninputs) { /* stereo effect */
 781                     /* copy the handle from previous channel */
 782                     setup->chhandles[i] = setup->chhandles[i-1];
 783                     continue;
 784                 }
 785
 786                 setup->chhandles[i] = pdes->instantiate(pdes, rate);
 787             }
 788         }
 789
 790         /* connect input/output ports for each channel/filter instance
 791          *
 792          * always (re)connect ports
 793          */
 794
 795         for(i=0; i<nch; i++) {
 796             pdes->connect_port(setup->chhandles[i],
 797                                setup->inputs[i % setup->ninputs],
 798                                setup->inbufs[i]);
 799             pdes->connect_port(setup->chhandles[i],
 800                                setup->outputs[i % setup->ninputs],
 801                                setup->outbufs[i]);
 802
 803             /* connect (input) controls */
 804
 805             for (p=0; p<setup->nports; p++) {
 806                 LADSPA_PortDescriptor d = pdes->PortDescriptors[p];
 807                 if (LADSPA_IS_PORT_CONTROL(d)) {
 808                     if (LADSPA_IS_PORT_INPUT(d)) {
 809                         pdes->connect_port(setup->chhandles[i], p,
 810                                                 &(setup->inputcontrols[p]) );
 811                     } else {
 812                         pdes->connect_port(setup->chhandles[i], p,
 813                                                 &(setup->outputcontrols[p]) );
 814                     }
 815                 }
 816             }
 817
 818             /* Activate filter (if it isn't already :) ) */
 819
 820             if (pdes->activate && !setup->activated && i % setup->ninputs == 0)
 821                 pdes->activate(setup->chhandles[i]);
 822
 823         } /* All channels/filters done! except for... */
 824         setup->activated = 1;
 825
 826         /* Stereo effect with one channel left. Use same buffer for left
 827          * and right. connect it to the second port.
 828          */
 829
 830         for (p = i; p % setup->ninputs; p++) {
 831             pdes->connect_port(setup->chhandles[i-1],
 832                                setup->inputs[p % setup->ninputs],
 833                                setup->inbufs[i-1]);
 834             pdes->connect_port(setup->chhandles[i-1],
 835                                setup->outputs[p % setup->ninputs],
 836                                setup->outbufs[i-1]);
 837         } /* done! */
 838
 839     } /* setup for first call/change of bufsize is done.
 840        * normal playing routine follows...
 841        */
 842
 843     /* Right now, I use a separate input and output buffer.
 844      * I could change this to in-place processing (inbuf==outbuf), but some
 845      * ladspa filters are broken and are not able to handle that. This seems
 846      * fast enough, so unless somebody complains, it stays this way :)
 847      */
 848
 849     /* Fill inbufs */
 850
 851     for (p=0; p<setup->bufsize; p++) {
 852         for (i=0; i<nch; i++) {
 853             setup->inbufs[i][p] = audio[p*nch + i];
 854         }
 855     }
 856
 857     /* Run filter(s) */
 858
 859     for (i=0; i<nch; i+=setup->ninputs) {
 860         pdes->run(setup->chhandles[i], setup->bufsize);
 861     }
 862
 863     /* Extract outbufs */
 864
 865     for (p=0; p<setup->bufsize; p++) {
 866         for (i=0; i<nch; i++) {
 867             audio[p*nch + i] = setup->outbufs[i][p];
 868         }
 869     }
 870
 871     /* done */
 872
 873     return data;
 874 }
 875
 876 /* ------------------------------------------------------------------------- */
 877
 878 /** \brief Open LADSPA Plugin Loader Filter
 879  *
 880  * \param af    Audio Filter instance
 881  *
 882  * \return      Either AF_ERROR or AF_OK
 883  */
 884
 885 static int af_open(af_instance_t *af) {
 886
 887     af->control=control;
 888     af->uninit=uninit;
 889     af->play=play;
 890     af->mul=1;
 891
 892     af->data = calloc(1, sizeof(af_data_t));
 893     if (af->data == NULL)
 894         return af_ladspa_malloc_failed((char*)af_info_ladspa.name);
 895
 896     af->setup = calloc(1, sizeof(af_ladspa_t));
 897     if (af->setup == NULL) {
 898         free(af->data);
 899         af->data=NULL;
 900         return af_ladspa_malloc_failed((char*)af_info_ladspa.name);
 901     }
 902
 903     ((af_ladspa_t*)af->setup)->status = AF_ERROR; /* will be set to AF_OK if
 904                                                    * all went OK and play()
 905                                                    * should proceed.
 906                                                    */
 907
 908     ((af_ladspa_t*)af->setup)->myname = strdup(af_info_ladspa.name);
 909     if (!((af_ladspa_t*)af->setup)->myname)
 910         return af_ladspa_malloc_failed((char*)af_info_ladspa.name);
 911
 912     return AF_OK;
 913 }
 914
 915 /* ------------------------------------------------------------------------- */