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
 514         mp_msg(MSGT_AFILTER, MSGL_V, "%s: parse suboptions\n", setup->myname);
 515
 516         /* suboption parser here!
 517          * format is (ladspa=)file:label:controls....
 518          */
 519
 520         if (!arg) {
 521             mp_msg(MSGT_AFILTER, MSGL_ERR, "%s: %s\n", setup->myname,
 522                                             _("No suboptions specified."));
 523             return AF_ERROR;
 524         }
 525
 526         buf = malloc(strlen(arg)+1);
 527         if (!buf) return af_ladspa_malloc_failed(setup->myname);
 528
 529         /* file... */
 530         buf[0] = '\0';
 531         sscanf(arg, "%[^:]", buf);
 532         if (buf[0] == '\0') {
 533             mp_msg(MSGT_AFILTER, MSGL_ERR, "%s: %s\n", setup->myname,
 534                                                 _("No library file specified."));
 535             free(buf);
 536             return AF_ERROR;
 537         }
 538         arg += strlen(buf);
 539         setup->file = strdup(buf);
 540         if (!setup->file) return af_ladspa_malloc_failed(setup->myname);
 541         mp_msg(MSGT_AFILTER, MSGL_V, "%s: file --> %s\n", setup->myname,
 542                                                         setup->file);
 543         if (*(char*)arg != '\0') arg++; /* read ':' */
 544
 545         /* label... */
 546         buf[0] = '\0';
 547         sscanf(arg, "%[^:]", buf);
 548         if (buf[0] == '\0') {
 549             mp_msg(MSGT_AFILTER, MSGL_ERR, "%s: %s\n", setup->myname,
 550                                                 _("No filter label specified."));
 551             free(buf);
 552             return AF_ERROR;
 553         }
 554         arg += strlen(buf);
 555         setup->label = strdup(buf);
 556         if (!setup->label) return af_ladspa_malloc_failed(setup->myname);
 557         mp_msg(MSGT_AFILTER, MSGL_V, "%s: label --> %s\n", setup->myname,
 558                                                                 setup->label);
 559 /*        if (*(char*)arg != '0') arg++; */ /* read ':' */
 560
 561         free(buf); /* no longer needed */
 562
 563         /* set new setup->myname */
 564
 565         free(setup->myname);
 566         setup->myname = calloc(strlen(af_info_ladspa.name)+strlen(setup->file)+
 567                                                     strlen(setup->label)+6, 1);
 568         snprintf(setup->myname, strlen(af_info_ladspa.name)+
 569                 strlen(setup->file)+strlen(setup->label)+6, "%s: (%s:%s)",
 570                             af_info_ladspa.name, setup->file, setup->label);
 571
 572         /* load plugin :) */
 573
 574         if ( af_ladspa_load_plugin(setup) != AF_OK )
 575             return AF_ERROR;
 576
 577         /* see what inputs, outputs and controls this plugin has */
 578         if ( af_ladspa_parse_plugin(setup) != AF_OK )
 579             return AF_ERROR;
 580
 581         /* ninputcontrols is set by now, read control values from arg */
 582
 583         for(i=0; i<setup->ninputcontrols; i++) {
 584             if (!arg || (*(char*)arg != ':') ) {
 585                 mp_msg(MSGT_AFILTER, MSGL_ERR, "%s: %s\n", setup->myname,
 586                                         _("Not enough controls specified on the command line."));
 587                 return AF_ERROR;
 588             }
 589             arg++;
 590             r = sscanf(arg, "%f", &val);
 591             if (r!=1) {
 592                 mp_msg(MSGT_AFILTER, MSGL_ERR, "%s: %s\n", setup->myname,
 593                                         _("Not enough controls specified on the command line."));
 594                 return AF_ERROR;
 595             }
 596             setup->inputcontrols[setup->inputcontrolsmap[i]] = val;
 597             arg = strchr(arg, ':');
 598         }
 599
 600         mp_msg(MSGT_AFILTER, MSGL_V, "%s: input controls: ", setup->myname);
 601         for(i=0; i<setup->ninputcontrols; i++) {
 602             mp_msg(MSGT_AFILTER, MSGL_V, "%0.4f ",
 603                             setup->inputcontrols[setup->inputcontrolsmap[i]]);
 604         }
 605         mp_msg(MSGT_AFILTER, MSGL_V, "\n");
 606
 607         /* check boundaries of inputcontrols */
 608
 609         mp_msg(MSGT_AFILTER, MSGL_V, "%s: checking boundaries of input controls\n",
 610                                                                 setup->myname);
 611         for(i=0; i<setup->ninputcontrols; i++) {
 612             int p = setup->inputcontrolsmap[i];
 613             LADSPA_PortRangeHint hint =
 614                                 setup->plugin_descriptor->PortRangeHints[p];
 615             val = setup->inputcontrols[p];
 616
 617             if (LADSPA_IS_HINT_BOUNDED_BELOW(hint.HintDescriptor) &&
 618                     val < hint.LowerBound) {
 619                 mp_tmsg(MSGT_AFILTER, MSGL_ERR, "%s: Input control #%d is below lower boundary of %0.4f.\n",
 620                                             setup->myname, i, hint.LowerBound);
 621                 return AF_ERROR;
 622             }
 623             if (LADSPA_IS_HINT_BOUNDED_ABOVE(hint.HintDescriptor) &&
 624                     val > hint.UpperBound) {
 625                 mp_tmsg(MSGT_AFILTER, MSGL_ERR, "%s: Input control #%d is above upper boundary of %0.4f.\n",
 626                                             setup->myname, i, hint.UpperBound);
 627                 return AF_ERROR;
 628             }
 629         }
 630         mp_msg(MSGT_AFILTER, MSGL_V, "%s: all controls have sane values\n",
 631                                                                 setup->myname);
 632
 633         /* All is well! */
 634         setup->status = AF_OK;
 635
 636         return AF_OK; }
 637     }
 638
 639     return AF_UNKNOWN;
 640 }
 641
 642 /* ------------------------------------------------------------------------- */
 643
 644 /** \brief Uninitialise the LADSPA Plugin Loader filter.
 645  *
 646  * This function deactivates the plugin(s), cleans up, frees all allocated
 647  * memory and exits.
 648  *
 649  * \return  No return value.
 650  */
 651
 652 static void uninit(struct af_instance_s *af) {
 653     int i;
 654
 655     free(af->data);
 656     if (af->setup) {
 657         af_ladspa_t *setup = (af_ladspa_t*) af->setup;
 658         const LADSPA_Descriptor *pdes = setup->plugin_descriptor;
 659
 660         if (setup->myname) {
 661             mp_msg(MSGT_AFILTER, MSGL_V, "%s: cleaning up\n", setup->myname);
 662             free(setup->myname);
 663         }
 664
 665         if (setup->chhandles) {
 666             for(i=0; i<setup->nch; i+=setup->ninputs) {
 667                 if (pdes->deactivate) pdes->deactivate(setup->chhandles[i]);
 668                 if (pdes->cleanup) pdes->cleanup(setup->chhandles[i]);
 669             }
 670             free(setup->chhandles);
 671         }
 672
 673         free(setup->file);
 674         free(setup->label);
 675         free(setup->inputcontrolsmap);
 676         free(setup->inputcontrols);
 677         free(setup->outputcontrolsmap);
 678         free(setup->outputcontrols);
 679         free(setup->inputs);
 680         free(setup->outputs);
 681
 682         if (setup->inbufs) {
 683             for(i=0; i<setup->nch; i++)
 684                 free(setup->inbufs[i]);
 685             free(setup->inbufs);
 686         }
 687
 688         if (setup->outbufs) {
 689             for(i=0; i<setup->nch; i++)
 690                 free(setup->outbufs[i]);
 691             free(setup->outbufs);
 692         }
 693
 694         if (setup->libhandle)
 695             dlclose(setup->libhandle);
 696
 697         free(setup);
 698         setup = NULL;
 699     }
 700 }
 701
 702 /* ------------------------------------------------------------------------- */
 703
 704 /** \brief Process chunk of audio data through the selected LADSPA Plugin.
 705  *
 706  * \param af    Pointer to audio filter instance
 707  * \param data  Pointer to chunk of audio data
 708  *
 709  * \return      Either AF_ERROR or AF_OK
 710  */
 711
 712 static af_data_t* play(struct af_instance_s *af, af_data_t *data) {
 713     af_ladspa_t *setup = af->setup;
 714     const LADSPA_Descriptor *pdes = setup->plugin_descriptor;
 715     float *audio = (float*)data->audio;
 716     int nsamples = data->len/4; /* /4 because it's 32-bit float */
 717     int nch = data->nch;
 718     int rate = data->rate;
 719     int i, p;
 720
 721     if (setup->status !=AF_OK)
 722         return data;
 723
 724     /* See if it's the first call. If so, setup inbufs/outbufs, instantiate
 725      * plugin, connect ports and activate plugin
 726      */
 727
 728     /* 2004-12-07: Also check if the buffersize has to be changed!
 729      *             data->len is not constant per se! re-init buffers.
 730      */
 731
 732     if ( (setup->bufsize != nsamples/nch) || (setup->nch != nch) ) {
 733
 734         /* if setup->nch==0, it's the first call, if not, something has
 735          * changed and all previous mallocs have to be freed
 736          */
 737
 738         if (setup->nch != 0) {
 739             mp_msg(MSGT_AFILTER, MSGL_DBG3, "%s: bufsize change; free old buffer\n",
 740                                                                 setup->myname);
 741
 742             if(setup->inbufs) {
 743                 for(i=0; i<setup->nch; i++)
 744                     free(setup->inbufs[i]);
 745                 free(setup->inbufs);
 746             }
 747             if(setup->outbufs) {
 748                 for(i=0; i<setup->nch; i++)
 749                     free(setup->outbufs[i]);
 750                 free(setup->outbufs);
 751             }
 752         } /* everything is freed */
 753
 754         setup->bufsize = nsamples/nch;
 755         setup->nch = nch;
 756
 757         setup->inbufs = calloc(nch, sizeof(float*));
 758         setup->outbufs = calloc(nch, sizeof(float*));
 759
 760         mp_msg(MSGT_AFILTER, MSGL_DBG3, "%s: bufsize = %d\n",
 761                                         setup->myname, setup->bufsize);
 762
 763         for(i=0; i<nch; i++) {
 764             setup->inbufs[i] = calloc(setup->bufsize, sizeof(float));
 765             setup->outbufs[i] = calloc(setup->bufsize, sizeof(float));
 766         }
 767
 768         /* only on the first call, there are no handles. */
 769
 770         if (!setup->chhandles) {
 771             setup->chhandles = calloc(nch, sizeof(LADSPA_Handle));
 772
 773             /* create handles
 774              * for stereo effects, create one handle for two channels
 775              */
 776
 777             for(i=0; i<nch; i++) {
 778
 779                 if (i % setup->ninputs) { /* stereo effect */
 780                     /* copy the handle from previous channel */
 781                     setup->chhandles[i] = setup->chhandles[i-1];
 782                     continue;
 783                 }
 784
 785                 setup->chhandles[i] = pdes->instantiate(pdes, rate);
 786             }
 787         }
 788
 789         /* connect input/output ports for each channel/filter instance
 790          *
 791          * always (re)connect ports
 792          */
 793
 794         for(i=0; i<nch; i++) {
 795             pdes->connect_port(setup->chhandles[i],
 796                                setup->inputs[i % setup->ninputs],
 797                                setup->inbufs[i]);
 798             pdes->connect_port(setup->chhandles[i],
 799                                setup->outputs[i % setup->ninputs],
 800                                setup->outbufs[i]);
 801
 802             /* connect (input) controls */
 803
 804             for (p=0; p<setup->nports; p++) {
 805                 LADSPA_PortDescriptor d = pdes->PortDescriptors[p];
 806                 if (LADSPA_IS_PORT_CONTROL(d)) {
 807                     if (LADSPA_IS_PORT_INPUT(d)) {
 808                         pdes->connect_port(setup->chhandles[i], p,
 809                                                 &(setup->inputcontrols[p]) );
 810                     } else {
 811                         pdes->connect_port(setup->chhandles[i], p,
 812                                                 &(setup->outputcontrols[p]) );
 813                     }
 814                 }
 815             }
 816
 817             /* Activate filter (if it isn't already :) ) */
 818
 819             if (pdes->activate && !setup->activated && i % setup->ninputs == 0)
 820                 pdes->activate(setup->chhandles[i]);
 821
 822         } /* All channels/filters done! except for... */
 823         setup->activated = 1;
 824
 825         /* Stereo effect with one channel left. Use same buffer for left
 826          * and right. connect it to the second port.
 827          */
 828
 829         for (p = i; p % setup->ninputs; p++) {
 830             pdes->connect_port(setup->chhandles[i-1],
 831                                setup->inputs[p % setup->ninputs],
 832                                setup->inbufs[i-1]);
 833             pdes->connect_port(setup->chhandles[i-1],
 834                                setup->outputs[p % setup->ninputs],
 835                                setup->outbufs[i-1]);
 836         } /* done! */
 837
 838     } /* setup for first call/change of bufsize is done.
 839        * normal playing routine follows...
 840        */
 841
 842     /* Right now, I use a separate input and output buffer.
 843      * I could change this to in-place processing (inbuf==outbuf), but some
 844      * ladspa filters are broken and are not able to handle that. This seems
 845      * fast enough, so unless somebody complains, it stays this way :)
 846      */
 847
 848     /* Fill inbufs */
 849
 850     for (p=0; p<setup->bufsize; p++) {
 851         for (i=0; i<nch; i++) {
 852             setup->inbufs[i][p] = audio[p*nch + i];
 853         }
 854     }
 855
 856     /* Run filter(s) */
 857
 858     for (i=0; i<nch; i+=setup->ninputs) {
 859         pdes->run(setup->chhandles[i], setup->bufsize);
 860     }
 861
 862     /* Extract outbufs */
 863
 864     for (p=0; p<setup->bufsize; p++) {
 865         for (i=0; i<nch; i++) {
 866             audio[p*nch + i] = setup->outbufs[i][p];
 867         }
 868     }
 869
 870     /* done */
 871
 872     return data;
 873 }
 874
 875 /* ------------------------------------------------------------------------- */
 876
 877 /** \brief Open LADSPA Plugin Loader Filter
 878  *
 879  * \param af    Audio Filter instance
 880  *
 881  * \return      Either AF_ERROR or AF_OK
 882  */
 883
 884 static int af_open(af_instance_t *af) {
 885
 886     af->control=control;
 887     af->uninit=uninit;
 888     af->play=play;
 889     af->mul=1;
 890
 891     af->data = calloc(1, sizeof(af_data_t));
 892     if (af->data == NULL)
 893         return af_ladspa_malloc_failed((char*)af_info_ladspa.name);
 894
 895     af->setup = calloc(1, sizeof(af_ladspa_t));
 896     if (af->setup == NULL) {
 897         free(af->data);
 898         af->data=NULL;
 899         return af_ladspa_malloc_failed((char*)af_info_ladspa.name);
 900     }
 901
 902     ((af_ladspa_t*)af->setup)->status = AF_ERROR; /* will be set to AF_OK if
 903                                                    * all went OK and play()
 904                                                    * should proceed.
 905                                                    */
 906
 907     ((af_ladspa_t*)af->setup)->myname = strdup(af_info_ladspa.name);
 908     if (!((af_ladspa_t*)af->setup)->myname)
 909         return af_ladspa_malloc_failed((char*)af_info_ladspa.name);
 910
 911     return AF_OK;
 912 }
 913
 914 /* ------------------------------------------------------------------------- */