FFmpeg
af_ladspa.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2013 Paul B Mahol
3  * Copyright (c) 2011 Mina Nagy Zaki
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * LADSPA wrapper
25  */
26 
27 #include <dlfcn.h>
28 #include <ladspa.h>
29 #include "libavutil/avassert.h"
30 #include "libavutil/avstring.h"
32 #include "libavutil/opt.h"
33 #include "audio.h"
34 #include "avfilter.h"
35 #include "internal.h"
36 
37 typedef struct LADSPAContext {
38  const AVClass *class;
39  char *dl_name;
40  char *plugin;
41  char *options;
42  void *dl_handle;
43 
44  unsigned long nb_inputs;
45  unsigned long *ipmap; /* map input number to port number */
46 
47  unsigned long nb_inputcontrols;
48  unsigned long *icmap; /* map input control number to port number */
49  LADSPA_Data *ictlv; /* input controls values */
50 
51  unsigned long nb_outputs;
52  unsigned long *opmap; /* map output number to port number */
53 
54  unsigned long nb_outputcontrols;
55  unsigned long *ocmap; /* map output control number to port number */
56  LADSPA_Data *octlv; /* output controls values */
57 
58  const LADSPA_Descriptor *desc;
61  LADSPA_Handle *handles;
62 
65  int64_t pts;
66  int64_t duration;
68 
69 #define OFFSET(x) offsetof(LADSPAContext, x)
70 #define FLAGS AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM
71 static const AVOption ladspa_options[] = {
72  { "file", "set library name or full path", OFFSET(dl_name), AV_OPT_TYPE_STRING, .flags = FLAGS },
73  { "f", "set library name or full path", OFFSET(dl_name), AV_OPT_TYPE_STRING, .flags = FLAGS },
74  { "plugin", "set plugin name", OFFSET(plugin), AV_OPT_TYPE_STRING, .flags = FLAGS },
75  { "p", "set plugin name", OFFSET(plugin), AV_OPT_TYPE_STRING, .flags = FLAGS },
76  { "controls", "set plugin options", OFFSET(options), AV_OPT_TYPE_STRING, .flags = FLAGS },
77  { "c", "set plugin options", OFFSET(options), AV_OPT_TYPE_STRING, .flags = FLAGS },
78  { "sample_rate", "set sample rate", OFFSET(sample_rate), AV_OPT_TYPE_INT, {.i64=44100}, 1, INT32_MAX, FLAGS },
79  { "s", "set sample rate", OFFSET(sample_rate), AV_OPT_TYPE_INT, {.i64=44100}, 1, INT32_MAX, FLAGS },
80  { "nb_samples", "set the number of samples per requested frame", OFFSET(nb_samples), AV_OPT_TYPE_INT, {.i64=1024}, 1, INT_MAX, FLAGS },
81  { "n", "set the number of samples per requested frame", OFFSET(nb_samples), AV_OPT_TYPE_INT, {.i64=1024}, 1, INT_MAX, FLAGS },
82  { "duration", "set audio duration", OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64=-1}, -1, INT64_MAX, FLAGS },
83  { "d", "set audio duration", OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64=-1}, -1, INT64_MAX, FLAGS },
84  { NULL }
85 };
86 
87 AVFILTER_DEFINE_CLASS(ladspa);
88 
90  LADSPAContext *s, int ctl, unsigned long *map,
91  LADSPA_Data *values, int print)
92 {
93  const LADSPA_PortRangeHint *h = s->desc->PortRangeHints + map[ctl];
94 
95  av_log(ctx, level, "c%i: %s [", ctl, s->desc->PortNames[map[ctl]]);
96 
97  if (LADSPA_IS_HINT_TOGGLED(h->HintDescriptor)) {
98  av_log(ctx, level, "toggled (1 or 0)");
99 
100  if (LADSPA_IS_HINT_HAS_DEFAULT(h->HintDescriptor))
101  av_log(ctx, level, " (default %i)", (int)values[ctl]);
102  } else {
103  if (LADSPA_IS_HINT_INTEGER(h->HintDescriptor)) {
104  av_log(ctx, level, "<int>");
105 
106  if (LADSPA_IS_HINT_BOUNDED_BELOW(h->HintDescriptor))
107  av_log(ctx, level, ", min: %i", (int)h->LowerBound);
108 
109  if (LADSPA_IS_HINT_BOUNDED_ABOVE(h->HintDescriptor))
110  av_log(ctx, level, ", max: %i", (int)h->UpperBound);
111 
112  if (print)
113  av_log(ctx, level, " (value %d)", (int)values[ctl]);
114  else if (LADSPA_IS_HINT_HAS_DEFAULT(h->HintDescriptor))
115  av_log(ctx, level, " (default %d)", (int)values[ctl]);
116  } else {
117  av_log(ctx, level, "<float>");
118 
119  if (LADSPA_IS_HINT_BOUNDED_BELOW(h->HintDescriptor))
120  av_log(ctx, level, ", min: %f", h->LowerBound);
121 
122  if (LADSPA_IS_HINT_BOUNDED_ABOVE(h->HintDescriptor))
123  av_log(ctx, level, ", max: %f", h->UpperBound);
124 
125  if (print)
126  av_log(ctx, level, " (value %f)", values[ctl]);
127  else if (LADSPA_IS_HINT_HAS_DEFAULT(h->HintDescriptor))
128  av_log(ctx, level, " (default %f)", values[ctl]);
129  }
130 
131  if (LADSPA_IS_HINT_SAMPLE_RATE(h->HintDescriptor))
132  av_log(ctx, level, ", multiple of sample rate");
133 
134  if (LADSPA_IS_HINT_LOGARITHMIC(h->HintDescriptor))
135  av_log(ctx, level, ", logarithmic scale");
136  }
137 
138  av_log(ctx, level, "]\n");
139 }
140 
142 {
143  AVFilterContext *ctx = inlink->dst;
144  LADSPAContext *s = ctx->priv;
145  AVFrame *out;
146  int i, h, p;
147 
148  av_assert0(in->channels == (s->nb_inputs * s->nb_handles));
149 
150  if (!s->nb_outputs ||
151  (av_frame_is_writable(in) && s->nb_inputs == s->nb_outputs &&
152  !(s->desc->Properties & LADSPA_PROPERTY_INPLACE_BROKEN))) {
153  out = in;
154  } else {
155  out = ff_get_audio_buffer(ctx->outputs[0], in->nb_samples);
156  if (!out) {
157  av_frame_free(&in);
158  return AVERROR(ENOMEM);
159  }
160  av_frame_copy_props(out, in);
161  }
162 
163  av_assert0(!s->nb_outputs || out->channels == (s->nb_outputs * s->nb_handles));
164 
165  for (h = 0; h < s->nb_handles; h++) {
166  for (i = 0; i < s->nb_inputs; i++) {
167  p = s->nb_handles > 1 ? h : i;
168  s->desc->connect_port(s->handles[h], s->ipmap[i],
169  (LADSPA_Data*)in->extended_data[p]);
170  }
171 
172  for (i = 0; i < s->nb_outputs; i++) {
173  p = s->nb_handles > 1 ? h : i;
174  s->desc->connect_port(s->handles[h], s->opmap[i],
175  (LADSPA_Data*)out->extended_data[p]);
176  }
177 
178  s->desc->run(s->handles[h], in->nb_samples);
179  }
180 
181  for (i = 0; i < s->nb_outputcontrols; i++)
182  print_ctl_info(ctx, AV_LOG_VERBOSE, s, i, s->ocmap, s->octlv, 1);
183 
184  if (out != in)
185  av_frame_free(&in);
186 
187  return ff_filter_frame(ctx->outputs[0], out);
188 }
189 
190 static int request_frame(AVFilterLink *outlink)
191 {
192  AVFilterContext *ctx = outlink->src;
193  LADSPAContext *s = ctx->priv;
194  AVFrame *out;
195  int64_t t;
196  int i;
197 
198  if (ctx->nb_inputs)
199  return ff_request_frame(ctx->inputs[0]);
200 
201  t = av_rescale(s->pts, AV_TIME_BASE, s->sample_rate);
202  if (s->duration >= 0 && t >= s->duration)
203  return AVERROR_EOF;
204 
205  out = ff_get_audio_buffer(outlink, s->nb_samples);
206  if (!out)
207  return AVERROR(ENOMEM);
208 
209  for (i = 0; i < s->nb_outputs; i++)
210  s->desc->connect_port(s->handles[0], s->opmap[i],
211  (LADSPA_Data*)out->extended_data[i]);
212 
213  s->desc->run(s->handles[0], s->nb_samples);
214 
215  for (i = 0; i < s->nb_outputcontrols; i++)
216  print_ctl_info(ctx, AV_LOG_INFO, s, i, s->ocmap, s->octlv, 1);
217 
218  out->sample_rate = s->sample_rate;
219  out->pts = s->pts;
220  s->pts += s->nb_samples;
221 
222  return ff_filter_frame(outlink, out);
223 }
224 
225 static void set_default_ctl_value(LADSPAContext *s, int ctl,
226  unsigned long *map, LADSPA_Data *values)
227 {
228  const LADSPA_PortRangeHint *h = s->desc->PortRangeHints + map[ctl];
229  const LADSPA_Data lower = h->LowerBound;
230  const LADSPA_Data upper = h->UpperBound;
231 
232  if (LADSPA_IS_HINT_DEFAULT_MINIMUM(h->HintDescriptor)) {
233  values[ctl] = lower;
234  } else if (LADSPA_IS_HINT_DEFAULT_MAXIMUM(h->HintDescriptor)) {
235  values[ctl] = upper;
236  } else if (LADSPA_IS_HINT_DEFAULT_0(h->HintDescriptor)) {
237  values[ctl] = 0.0;
238  } else if (LADSPA_IS_HINT_DEFAULT_1(h->HintDescriptor)) {
239  values[ctl] = 1.0;
240  } else if (LADSPA_IS_HINT_DEFAULT_100(h->HintDescriptor)) {
241  values[ctl] = 100.0;
242  } else if (LADSPA_IS_HINT_DEFAULT_440(h->HintDescriptor)) {
243  values[ctl] = 440.0;
244  } else if (LADSPA_IS_HINT_DEFAULT_LOW(h->HintDescriptor)) {
245  if (LADSPA_IS_HINT_LOGARITHMIC(h->HintDescriptor))
246  values[ctl] = exp(log(lower) * 0.75 + log(upper) * 0.25);
247  else
248  values[ctl] = lower * 0.75 + upper * 0.25;
249  } else if (LADSPA_IS_HINT_DEFAULT_MIDDLE(h->HintDescriptor)) {
250  if (LADSPA_IS_HINT_LOGARITHMIC(h->HintDescriptor))
251  values[ctl] = exp(log(lower) * 0.5 + log(upper) * 0.5);
252  else
253  values[ctl] = lower * 0.5 + upper * 0.5;
254  } else if (LADSPA_IS_HINT_DEFAULT_HIGH(h->HintDescriptor)) {
255  if (LADSPA_IS_HINT_LOGARITHMIC(h->HintDescriptor))
256  values[ctl] = exp(log(lower) * 0.25 + log(upper) * 0.75);
257  else
258  values[ctl] = lower * 0.25 + upper * 0.75;
259  }
260 }
261 
263 {
264  LADSPAContext *s = ctx->priv;
265  int i, j;
266 
267  s->nb_handles = s->nb_inputs == 1 && s->nb_outputs == 1 ? link->channels : 1;
268  s->handles = av_calloc(s->nb_handles, sizeof(*s->handles));
269  if (!s->handles)
270  return AVERROR(ENOMEM);
271 
272  for (i = 0; i < s->nb_handles; i++) {
273  s->handles[i] = s->desc->instantiate(s->desc, link->sample_rate);
274  if (!s->handles[i]) {
275  av_log(ctx, AV_LOG_ERROR, "Could not instantiate plugin.\n");
276  return AVERROR_EXTERNAL;
277  }
278 
279  // Connect the input control ports
280  for (j = 0; j < s->nb_inputcontrols; j++)
281  s->desc->connect_port(s->handles[i], s->icmap[j], s->ictlv + j);
282 
283  // Connect the output control ports
284  for (j = 0; j < s->nb_outputcontrols; j++)
285  s->desc->connect_port(s->handles[i], s->ocmap[j], &s->octlv[j]);
286 
287  if (s->desc->activate)
288  s->desc->activate(s->handles[i]);
289  }
290 
291  av_log(ctx, AV_LOG_DEBUG, "handles: %d\n", s->nb_handles);
292 
293  return 0;
294 }
295 
297 {
298  AVFilterContext *ctx = inlink->dst;
299 
300  return connect_ports(ctx, inlink);
301 }
302 
303 static int config_output(AVFilterLink *outlink)
304 {
305  AVFilterContext *ctx = outlink->src;
306  LADSPAContext *s = ctx->priv;
307  int ret;
308 
309  if (ctx->nb_inputs) {
310  AVFilterLink *inlink = ctx->inputs[0];
311 
312  outlink->format = inlink->format;
313  outlink->sample_rate = inlink->sample_rate;
314  if (s->nb_inputs == s->nb_outputs) {
315  outlink->channel_layout = inlink->channel_layout;
316  outlink->channels = inlink->channels;
317  }
318 
319  ret = 0;
320  } else {
321  outlink->sample_rate = s->sample_rate;
322  outlink->time_base = (AVRational){1, s->sample_rate};
323 
324  ret = connect_ports(ctx, outlink);
325  }
326 
327  return ret;
328 }
329 
330 static void count_ports(const LADSPA_Descriptor *desc,
331  unsigned long *nb_inputs, unsigned long *nb_outputs)
332 {
333  LADSPA_PortDescriptor pd;
334  int i;
335 
336  for (i = 0; i < desc->PortCount; i++) {
337  pd = desc->PortDescriptors[i];
338 
339  if (LADSPA_IS_PORT_AUDIO(pd)) {
340  if (LADSPA_IS_PORT_INPUT(pd)) {
341  (*nb_inputs)++;
342  } else if (LADSPA_IS_PORT_OUTPUT(pd)) {
343  (*nb_outputs)++;
344  }
345  }
346  }
347 }
348 
349 static void *try_load(const char *dir, const char *soname)
350 {
351  char *path = av_asprintf("%s/%s.so", dir, soname);
352  void *ret = NULL;
353 
354  if (path) {
355  ret = dlopen(path, RTLD_LOCAL|RTLD_NOW);
356  av_free(path);
357  }
358 
359  return ret;
360 }
361 
362 static int set_control(AVFilterContext *ctx, unsigned long port, LADSPA_Data value)
363 {
364  LADSPAContext *s = ctx->priv;
365  const char *label = s->desc->Label;
366  LADSPA_PortRangeHint *h = (LADSPA_PortRangeHint *)s->desc->PortRangeHints +
367  s->icmap[port];
368 
369  if (port >= s->nb_inputcontrols) {
370  av_log(ctx, AV_LOG_ERROR, "Control c%ld is out of range [0 - %lu].\n",
371  port, s->nb_inputcontrols);
372  return AVERROR(EINVAL);
373  }
374 
375  if (LADSPA_IS_HINT_BOUNDED_BELOW(h->HintDescriptor) &&
376  value < h->LowerBound) {
377  av_log(ctx, AV_LOG_ERROR,
378  "%s: input control c%ld is below lower boundary of %0.4f.\n",
379  label, port, h->LowerBound);
380  return AVERROR(EINVAL);
381  }
382 
383  if (LADSPA_IS_HINT_BOUNDED_ABOVE(h->HintDescriptor) &&
384  value > h->UpperBound) {
385  av_log(ctx, AV_LOG_ERROR,
386  "%s: input control c%ld is above upper boundary of %0.4f.\n",
387  label, port, h->UpperBound);
388  return AVERROR(EINVAL);
389  }
390 
391  s->ictlv[port] = value;
392 
393  return 0;
394 }
395 
397 {
398  LADSPAContext *s = ctx->priv;
399  LADSPA_Descriptor_Function descriptor_fn;
400  const LADSPA_Descriptor *desc;
401  LADSPA_PortDescriptor pd;
402  AVFilterPad pad = { NULL };
403  char *p, *arg, *saveptr = NULL;
404  unsigned long nb_ports;
405  int i, j = 0;
406 
407  if (!s->dl_name) {
408  av_log(ctx, AV_LOG_ERROR, "No plugin name provided\n");
409  return AVERROR(EINVAL);
410  }
411 
412  if (s->dl_name[0] == '/' || s->dl_name[0] == '.') {
413  // argument is a path
414  s->dl_handle = dlopen(s->dl_name, RTLD_LOCAL|RTLD_NOW);
415  } else {
416  // argument is a shared object name
417  char *paths = av_strdup(getenv("LADSPA_PATH"));
418  const char *separator = ":";
419 
420  if (paths) {
421  p = paths;
422  while ((arg = av_strtok(p, separator, &saveptr)) && !s->dl_handle) {
423  s->dl_handle = try_load(arg, s->dl_name);
424  p = NULL;
425  }
426  }
427 
428  av_free(paths);
429  if (!s->dl_handle && (paths = av_asprintf("%s/.ladspa/lib", getenv("HOME")))) {
430  s->dl_handle = try_load(paths, s->dl_name);
431  av_free(paths);
432  }
433 
434  if (!s->dl_handle)
435  s->dl_handle = try_load("/usr/local/lib/ladspa", s->dl_name);
436 
437  if (!s->dl_handle)
438  s->dl_handle = try_load("/usr/lib/ladspa", s->dl_name);
439  }
440  if (!s->dl_handle) {
441  av_log(ctx, AV_LOG_ERROR, "Failed to load '%s'\n", s->dl_name);
442  return AVERROR(EINVAL);
443  }
444 
445  descriptor_fn = dlsym(s->dl_handle, "ladspa_descriptor");
446  if (!descriptor_fn) {
447  av_log(ctx, AV_LOG_ERROR, "Could not find ladspa_descriptor: %s\n", dlerror());
448  return AVERROR(EINVAL);
449  }
450 
451  // Find the requested plugin, or list plugins
452  if (!s->plugin) {
453  av_log(ctx, AV_LOG_INFO, "The '%s' library contains the following plugins:\n", s->dl_name);
454  av_log(ctx, AV_LOG_INFO, "I = Input Channels\n");
455  av_log(ctx, AV_LOG_INFO, "O = Output Channels\n");
456  av_log(ctx, AV_LOG_INFO, "I:O %-25s %s\n", "Plugin", "Description");
457  av_log(ctx, AV_LOG_INFO, "\n");
458  for (i = 0; desc = descriptor_fn(i); i++) {
459  unsigned long inputs = 0, outputs = 0;
460 
461  count_ports(desc, &inputs, &outputs);
462  av_log(ctx, AV_LOG_INFO, "%lu:%lu %-25s %s\n", inputs, outputs, desc->Label,
463  (char *)av_x_if_null(desc->Name, "?"));
464  av_log(ctx, AV_LOG_VERBOSE, "Maker: %s\n",
465  (char *)av_x_if_null(desc->Maker, "?"));
466  av_log(ctx, AV_LOG_VERBOSE, "Copyright: %s\n",
467  (char *)av_x_if_null(desc->Copyright, "?"));
468  }
469  return AVERROR_EXIT;
470  } else {
471  for (i = 0;; i++) {
472  desc = descriptor_fn(i);
473  if (!desc) {
474  av_log(ctx, AV_LOG_ERROR, "Could not find plugin: %s\n", s->plugin);
475  return AVERROR(EINVAL);
476  }
477 
478  if (desc->Label && !strcmp(desc->Label, s->plugin))
479  break;
480  }
481  }
482 
483  s->desc = desc;
484  nb_ports = desc->PortCount;
485 
486  s->ipmap = av_calloc(nb_ports, sizeof(*s->ipmap));
487  s->opmap = av_calloc(nb_ports, sizeof(*s->opmap));
488  s->icmap = av_calloc(nb_ports, sizeof(*s->icmap));
489  s->ocmap = av_calloc(nb_ports, sizeof(*s->ocmap));
490  s->ictlv = av_calloc(nb_ports, sizeof(*s->ictlv));
491  s->octlv = av_calloc(nb_ports, sizeof(*s->octlv));
492  s->ctl_needs_value = av_calloc(nb_ports, sizeof(*s->ctl_needs_value));
493  if (!s->ipmap || !s->opmap || !s->icmap ||
494  !s->ocmap || !s->ictlv || !s->octlv || !s->ctl_needs_value)
495  return AVERROR(ENOMEM);
496 
497  for (i = 0; i < nb_ports; i++) {
498  pd = desc->PortDescriptors[i];
499 
500  if (LADSPA_IS_PORT_AUDIO(pd)) {
501  if (LADSPA_IS_PORT_INPUT(pd)) {
502  s->ipmap[s->nb_inputs] = i;
503  s->nb_inputs++;
504  } else if (LADSPA_IS_PORT_OUTPUT(pd)) {
505  s->opmap[s->nb_outputs] = i;
506  s->nb_outputs++;
507  }
508  } else if (LADSPA_IS_PORT_CONTROL(pd)) {
509  if (LADSPA_IS_PORT_INPUT(pd)) {
510  s->icmap[s->nb_inputcontrols] = i;
511 
512  if (LADSPA_IS_HINT_HAS_DEFAULT(desc->PortRangeHints[i].HintDescriptor))
514  else
516 
517  s->nb_inputcontrols++;
518  } else if (LADSPA_IS_PORT_OUTPUT(pd)) {
519  s->ocmap[s->nb_outputcontrols] = i;
520  s->nb_outputcontrols++;
521  }
522  }
523  }
524 
525  // List Control Ports if "help" is specified
526  if (s->options && !strcmp(s->options, "help")) {
527  if (!s->nb_inputcontrols) {
528  av_log(ctx, AV_LOG_INFO,
529  "The '%s' plugin does not have any input controls.\n",
530  desc->Label);
531  } else {
532  av_log(ctx, AV_LOG_INFO,
533  "The '%s' plugin has the following input controls:\n",
534  desc->Label);
535  for (i = 0; i < s->nb_inputcontrols; i++)
536  print_ctl_info(ctx, AV_LOG_INFO, s, i, s->icmap, s->ictlv, 0);
537  }
538  return AVERROR_EXIT;
539  }
540 
541  // Parse control parameters
542  p = s->options;
543  while (s->options) {
544  LADSPA_Data val;
545  int ret;
546 
547  if (!(arg = av_strtok(p, " |", &saveptr)))
548  break;
549  p = NULL;
550 
551  if (av_sscanf(arg, "c%d=%f", &i, &val) != 2) {
552  if (av_sscanf(arg, "%f", &val) != 1) {
553  av_log(ctx, AV_LOG_ERROR, "Invalid syntax.\n");
554  return AVERROR(EINVAL);
555  }
556  i = j++;
557  }
558 
559  if ((ret = set_control(ctx, i, val)) < 0)
560  return ret;
561  s->ctl_needs_value[i] = 0;
562  }
563 
564  // Check if any controls are not set
565  for (i = 0; i < s->nb_inputcontrols; i++) {
566  if (s->ctl_needs_value[i]) {
567  av_log(ctx, AV_LOG_ERROR, "Control c%d must be set.\n", i);
568  print_ctl_info(ctx, AV_LOG_ERROR, s, i, s->icmap, s->ictlv, 0);
569  return AVERROR(EINVAL);
570  }
571  }
572 
573  pad.type = AVMEDIA_TYPE_AUDIO;
574 
575  if (s->nb_inputs) {
576  pad.name = av_asprintf("in0:%s%lu", desc->Label, s->nb_inputs);
577  if (!pad.name)
578  return AVERROR(ENOMEM);
579 
582  if (ff_insert_inpad(ctx, ctx->nb_inputs, &pad) < 0) {
583  av_freep(&pad.name);
584  return AVERROR(ENOMEM);
585  }
586  }
587 
588  av_log(ctx, AV_LOG_DEBUG, "ports: %lu\n", nb_ports);
589  av_log(ctx, AV_LOG_DEBUG, "inputs: %lu outputs: %lu\n",
590  s->nb_inputs, s->nb_outputs);
591  av_log(ctx, AV_LOG_DEBUG, "input controls: %lu output controls: %lu\n",
593 
594  return 0;
595 }
596 
598 {
599  LADSPAContext *s = ctx->priv;
602  static const enum AVSampleFormat sample_fmts[] = {
604  int ret;
605 
606  formats = ff_make_format_list(sample_fmts);
607  if (!formats)
608  return AVERROR(ENOMEM);
609  ret = ff_set_common_formats(ctx, formats);
610  if (ret < 0)
611  return ret;
612 
613  if (s->nb_inputs) {
614  formats = ff_all_samplerates();
615  if (!formats)
616  return AVERROR(ENOMEM);
617 
618  ret = ff_set_common_samplerates(ctx, formats);
619  if (ret < 0)
620  return ret;
621  } else {
622  int sample_rates[] = { s->sample_rate, -1 };
623 
624  ret = ff_set_common_samplerates(ctx, ff_make_format_list(sample_rates));
625  if (ret < 0)
626  return ret;
627  }
628 
629  if (s->nb_inputs == 1 && s->nb_outputs == 1) {
630  // We will instantiate multiple LADSPA_Handle, one over each channel
631  layouts = ff_all_channel_counts();
632  if (!layouts)
633  return AVERROR(ENOMEM);
634 
635  ret = ff_set_common_channel_layouts(ctx, layouts);
636  if (ret < 0)
637  return ret;
638  } else if (s->nb_inputs == 2 && s->nb_outputs == 2) {
639  layouts = NULL;
641  if (ret < 0)
642  return ret;
643  ret = ff_set_common_channel_layouts(ctx, layouts);
644  if (ret < 0)
645  return ret;
646  } else {
647  AVFilterLink *outlink = ctx->outputs[0];
648 
649  if (s->nb_inputs >= 1) {
650  AVFilterLink *inlink = ctx->inputs[0];
651  uint64_t inlayout = FF_COUNT2LAYOUT(s->nb_inputs);
652 
653  layouts = NULL;
654  ret = ff_add_channel_layout(&layouts, inlayout);
655  if (ret < 0)
656  return ret;
657  ret = ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts);
658  if (ret < 0)
659  return ret;
660 
661  if (!s->nb_outputs) {
662  ret = ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts);
663  if (ret < 0)
664  return ret;
665  }
666  }
667 
668  if (s->nb_outputs >= 1) {
669  uint64_t outlayout = FF_COUNT2LAYOUT(s->nb_outputs);
670 
671  layouts = NULL;
672  ret = ff_add_channel_layout(&layouts, outlayout);
673  if (ret < 0)
674  return ret;
675  ret = ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts);
676  if (ret < 0)
677  return ret;
678  }
679  }
680 
681  return 0;
682 }
683 
685 {
686  LADSPAContext *s = ctx->priv;
687  int i;
688 
689  for (i = 0; i < s->nb_handles; i++) {
690  if (s->desc->deactivate)
691  s->desc->deactivate(s->handles[i]);
692  if (s->desc->cleanup)
693  s->desc->cleanup(s->handles[i]);
694  }
695 
696  if (s->dl_handle)
697  dlclose(s->dl_handle);
698 
699  av_freep(&s->ipmap);
700  av_freep(&s->opmap);
701  av_freep(&s->icmap);
702  av_freep(&s->ocmap);
703  av_freep(&s->ictlv);
704  av_freep(&s->octlv);
705  av_freep(&s->handles);
707 
708  if (ctx->nb_inputs)
709  av_freep(&ctx->input_pads[0].name);
710 }
711 
712 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
713  char *res, int res_len, int flags)
714 {
715  LADSPA_Data value;
716  unsigned long port;
717 
718  if (av_sscanf(cmd, "c%ld", &port) + av_sscanf(args, "%f", &value) != 2)
719  return AVERROR(EINVAL);
720 
721  return set_control(ctx, port, value);
722 }
723 
724 static const AVFilterPad ladspa_outputs[] = {
725  {
726  .name = "default",
727  .type = AVMEDIA_TYPE_AUDIO,
728  .config_props = config_output,
729  .request_frame = request_frame,
730  },
731  { NULL }
732 };
733 
735  .name = "ladspa",
736  .description = NULL_IF_CONFIG_SMALL("Apply LADSPA effect."),
737  .priv_size = sizeof(LADSPAContext),
738  .priv_class = &ladspa_class,
739  .init = init,
740  .uninit = uninit,
743  .inputs = 0,
744  .outputs = ladspa_outputs,
746 };
static void set_default_ctl_value(LADSPAContext *s, int ctl, unsigned long *map, LADSPA_Data *values)
Definition: af_ladspa.c:225
float, planar
Definition: samplefmt.h:69
#define NULL
Definition: coverity.c:32
int ff_set_common_channel_layouts(AVFilterContext *ctx, AVFilterChannelLayouts *layouts)
A helper for query_formats() which sets all links to the same list of channel layouts/sample rates...
Definition: formats.c:549
const char const char void * val
Definition: avisynth_c.h:863
unsigned long * opmap
Definition: af_ladspa.c:52
AVFilter ff_af_ladspa
Definition: af_ladspa.c:734
void * dl_handle
Definition: af_ladspa.c:42
static int request_frame(AVFilterLink *outlink)
Definition: af_ladspa.c:190
This structure describes decoded (raw) audio or video data.
Definition: frame.h:268
AVOption.
Definition: opt.h:246
static int config_output(AVFilterLink *outlink)
Definition: af_ladspa.c:303
#define OFFSET(x)
Definition: af_ladspa.c:69
Main libavfilter public API header.
#define FLAGS
Definition: af_ladspa.c:70
int sample_rate
Definition: af_ladspa.c:63
#define AVFILTER_FLAG_DYNAMIC_INPUTS
The number of the filter inputs is not determined just by AVFilter.inputs.
Definition: avfilter.h:105
unsigned long nb_outputs
Definition: af_ladspa.c:51
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
Definition: af_ladspa.c:712
enum AVMediaType type
AVFilterPad type.
Definition: internal.h:65
#define AV_CH_LAYOUT_STEREO
char * options
Definition: af_ladspa.c:41
char * dl_name
Definition: af_ladspa.c:39
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:244
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283
LADSPA_Handle * handles
Definition: af_ladspa.c:61
LADSPA_Data * ictlv
Definition: af_ladspa.c:49
const char * name
Pad name.
Definition: internal.h:60
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:346
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
Add *ref as a new reference to f.
Definition: formats.c:435
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1080
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: af_ladspa.c:141
#define av_cold
Definition: attributes.h:82
AVOptions.
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
static void count_ports(const LADSPA_Descriptor *desc, unsigned long *nb_inputs, unsigned long *nb_outputs)
Definition: af_ladspa.c:330
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:361
int64_t duration
Definition: af_ladspa.c:66
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
int nb_handles
Definition: af_ladspa.c:60
AVFILTER_DEFINE_CLASS(ladspa)
#define av_log(a,...)
A filter pad used for either input or output.
Definition: internal.h:54
static void * av_x_if_null(const void *p, const void *x)
Return x default pointer in case p is NULL.
Definition: avutil.h:308
AVFilterPad * input_pads
array of input pads
Definition: avfilter.h:345
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:260
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition: formats.c:568
int ff_add_channel_layout(AVFilterChannelLayouts **l, uint64_t channel_layout)
Definition: formats.c:343
AVFrame * ff_get_audio_buffer(AVFilterLink *link, int nb_samples)
Request an audio samples buffer with a specific set of permissions.
Definition: audio.c:86
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
void * priv
private data for use by the filter
Definition: avfilter.h:353
const LADSPA_Descriptor * desc
Definition: af_ladspa.c:58
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
const char * arg
Definition: jacosubdec.c:66
simple assert() macros that are a bit more flexible than ISO C assert().
int8_t exp
Definition: eval.c:72
int av_sscanf(const char *string, const char *format,...)
See libc sscanf manual for more information.
Definition: avsscanf.c:962
int * ctl_needs_value
Definition: af_ladspa.c:59
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:113
int(* config_props)(AVFilterLink *link)
Link configuration callback.
Definition: internal.h:129
int channels
number of audio channels, only used for audio.
Definition: frame.h:573
audio channel layout utility functions
unsigned nb_inputs
number of input pads
Definition: avfilter.h:347
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
static av_cold int init(AVFilterContext *ctx)
Definition: af_ladspa.c:396
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return values
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static int set_control(AVFilterContext *ctx, unsigned long port, LADSPA_Data value)
Definition: af_ladspa.c:362
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
Definition: error.h:56
static av_cold void uninit(AVFilterContext *ctx)
Definition: af_ladspa.c:684
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
A list of supported channel layouts.
Definition: formats.h:85
if(ret)
static int config_input(AVFilterLink *inlink)
Definition: af_ladspa.c:296
static void * try_load(const char *dir, const char *soname)
Definition: af_ladspa.c:349
static const AVOption ladspa_options[]
Definition: af_ladspa.c:71
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
unsigned long nb_outputcontrols
Definition: af_ladspa.c:54
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:251
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
unsigned long * ipmap
Definition: af_ladspa.c:45
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:594
unsigned long nb_inputs
Definition: af_ladspa.c:44
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);return NULL;}return ac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
Describe the class of an AVClass context structure.
Definition: log.h:67
int sample_rate
Sample rate of the audio data.
Definition: frame.h:440
Filter definition.
Definition: avfilter.h:144
Rational number (pair of numerator and denominator).
Definition: rational.h:58
char * plugin
Definition: af_ladspa.c:40
static int query_formats(AVFilterContext *ctx)
Definition: af_ladspa.c:597
const char * name
Filter name.
Definition: avfilter.h:148
const VDPAUPixFmtMap * map
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a link
static int connect_ports(AVFilterContext *ctx, AVFilterLink *link)
Definition: af_ladspa.c:262
int nb_samples
Definition: af_ladspa.c:64
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
enum MovChannelLayoutTag * layouts
Definition: mov_chan.c:434
unsigned long * ocmap
Definition: af_ladspa.c:55
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:395
#define flags(name, subs,...)
Definition: cbs_av1.c:561
int(* filter_frame)(AVFilterLink *link, AVFrame *frame)
Filtering callback.
Definition: internal.h:93
static void print_ctl_info(AVFilterContext *ctx, int level, LADSPAContext *s, int ctl, unsigned long *map, LADSPA_Data *values, int print)
Definition: af_ladspa.c:89
uint8_t level
Definition: svq3.c:207
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
char * av_strtok(char *s, const char *delim, char **saveptr)
Split the string into several tokens which can be accessed by successive calls to av_strtok()...
Definition: avstring.c:184
sample_rates
unsigned long * icmap
Definition: af_ladspa.c:48
int64_t pts
Definition: af_ladspa.c:65
#define av_free(p)
A list of supported formats for one end of a filter link.
Definition: formats.h:64
static const AVFilterPad ladspa_outputs[]
Definition: af_ladspa.c:724
An instance of a filter.
Definition: avfilter.h:338
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:701
FILE * out
Definition: movenc.c:54
#define av_freep(p)
#define FF_COUNT2LAYOUT(c)
Encode a channel count as a channel layout.
Definition: formats.h:102
LADSPA_Data * octlv
Definition: af_ladspa.c:56
int ff_request_frame(AVFilterLink *link)
Request an input frame from the filter at the other end of the link.
Definition: avfilter.c:407
formats
Definition: signature.h:48
internal API functions
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
AVFilterChannelLayouts * ff_all_channel_counts(void)
Construct an AVFilterChannelLayouts coding for any channel layout, with known or unknown disposition...
Definition: formats.c:410
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:315
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:57
unsigned long nb_inputcontrols
Definition: af_ladspa.c:47
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:334
static void print(AVTreeNode *t, int depth)
Definition: tree.c:44
int ff_set_common_samplerates(AVFilterContext *ctx, AVFilterFormats *samplerates)
Definition: formats.c:556
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:654
static int ff_insert_inpad(AVFilterContext *f, unsigned index, AVFilterPad *p)
Insert a new input pad for the filter.
Definition: internal.h:277