static void print_ctl_info(AVFilterContext *ctx, int level, LADSPAContext *s, int ctl, unsigned long *map, LADSPA_Data *values, int print) { const LADSPA_PortRangeHint *h = s->desc->PortRangeHints + map[ctl]; av_log(ctx, level, "c%i: %s [", ctl, s->desc->PortNames[map[ctl]]); if (LADSPA_IS_HINT_TOGGLED(h->HintDescriptor)) { av_log(ctx, level, "toggled (1 or 0)"); if (LADSPA_IS_HINT_HAS_DEFAULT(h->HintDescriptor)) av_log(ctx, level, " (default %i)", (int)values[ctl]); } else { if (LADSPA_IS_HINT_INTEGER(h->HintDescriptor)) { av_log(ctx, level, "<int>"); if (LADSPA_IS_HINT_BOUNDED_BELOW(h->HintDescriptor)) av_log(ctx, level, ", min: %i", (int)h->LowerBound); if (LADSPA_IS_HINT_BOUNDED_ABOVE(h->HintDescriptor)) av_log(ctx, level, ", max: %i", (int)h->UpperBound); if (print) av_log(ctx, level, " (value %d)", (int)values[ctl]); else if (LADSPA_IS_HINT_HAS_DEFAULT(h->HintDescriptor)) av_log(ctx, level, " (default %d)", (int)values[ctl]); } else { av_log(ctx, level, "<float>"); if (LADSPA_IS_HINT_BOUNDED_BELOW(h->HintDescriptor)) av_log(ctx, level, ", min: %f", h->LowerBound); if (LADSPA_IS_HINT_BOUNDED_ABOVE(h->HintDescriptor)) av_log(ctx, level, ", max: %f", h->UpperBound); if (print) av_log(ctx, level, " (value %f)", values[ctl]); else if (LADSPA_IS_HINT_HAS_DEFAULT(h->HintDescriptor)) av_log(ctx, level, " (default %f)", values[ctl]); } if (LADSPA_IS_HINT_SAMPLE_RATE(h->HintDescriptor)) av_log(ctx, level, ", multiple of sample rate"); if (LADSPA_IS_HINT_LOGARITHMIC(h->HintDescriptor)) av_log(ctx, level, ", logarithmic scale"); } av_log(ctx, level, "]\n"); }
PRIVATE LADSPA_Data get_default( ControlDescriptor *control, LADSPA_PortRangeHintDescriptor hint ) { if( LADSPA_IS_HINT_HAS_DEFAULT( hint ) ) { if( LADSPA_IS_HINT_DEFAULT_MINIMUM( hint ) ) return control->min; if( LADSPA_IS_HINT_DEFAULT_LOW( hint ) ) return control->min * 0.75 + control->max * 0.25; if( LADSPA_IS_HINT_DEFAULT_MIDDLE( hint ) ) return control->min * 0.5 + control->max * 0.5; if( LADSPA_IS_HINT_DEFAULT_HIGH( hint ) ) return control->min * 0.25 + control->max * 0.75; if( LADSPA_IS_HINT_DEFAULT_MAXIMUM( hint ) ) return control->max; if( LADSPA_IS_HINT_DEFAULT_0( hint ) ) return 0.0; if( LADSPA_IS_HINT_DEFAULT_1( hint ) ) return 1.0; if( LADSPA_IS_HINT_DEFAULT_100( hint ) ) return 100.0; if( LADSPA_IS_HINT_DEFAULT_440( hint ) ) return 440.0; printf( "plugins says it has default... but i cant find out.\n" ); return 0.0; } else return 0.0; }
LADSPA_Data WiredLADSPAInstance::GetDefaultValue(t_gui_port *GuiPort, LADSPA_PortRangeHintDescriptor Descriptor) { if (LADSPA_IS_HINT_HAS_DEFAULT(Descriptor)) { if(LADSPA_IS_HINT_DEFAULT_MINIMUM(Descriptor)) return GuiPort->LowerBound; else if (LADSPA_IS_HINT_DEFAULT_LOW(Descriptor)) { if (LADSPA_IS_HINT_LOGARITHMIC(Descriptor)) return (LADSPA_Data) expf(logf(GuiPort->LowerBound) * 0.75 + logf(GuiPort->UpperBound) * 0.25); else return (LADSPA_Data) GuiPort->LowerBound * 0.75 + GuiPort->UpperBound * 0.25; } else if (LADSPA_IS_HINT_DEFAULT_MIDDLE(Descriptor)) { if (LADSPA_IS_HINT_LOGARITHMIC(Descriptor)) return (LADSPA_Data) expf(logf(GuiPort->LowerBound) * 0.5 + logf(GuiPort->UpperBound) * 0.5); else return (LADSPA_Data) GuiPort->LowerBound * 0.5 + GuiPort->UpperBound * 0.5; } else if (LADSPA_IS_HINT_DEFAULT_HIGH(Descriptor)) { if (LADSPA_IS_HINT_LOGARITHMIC(Descriptor)) return (LADSPA_Data) expf(logf(GuiPort->LowerBound) * 0.25 + logf(GuiPort->UpperBound) * 0.75); else return (LADSPA_Data) GuiPort->LowerBound * 0.25 + GuiPort->UpperBound * 0.75; } else if (LADSPA_IS_HINT_DEFAULT_MAXIMUM(Descriptor)) return GuiPort->UpperBound; else if (LADSPA_IS_HINT_DEFAULT_0(Descriptor)) return 0.0f; else if (LADSPA_IS_HINT_DEFAULT_1(Descriptor)) return 1.0f; else if (LADSPA_IS_HINT_DEFAULT_100(Descriptor)) return 100.0f; else if (LADSPA_IS_HINT_DEFAULT_440(Descriptor)) return 440.0f; } return GuiPort->LowerBound; }
//============================================================================== void DssiPlugin::setDefaultProgram () { if (ladspa == 0) return; // TODO - keep in a function instead ! for (int i = 0; i < pars.size (); i++) { const LADSPA_PortRangeHint* hint = & ladspa->PortRangeHints [pars [i]]; float lower = hint->LowerBound * (LADSPA_IS_HINT_SAMPLE_RATE (hint->HintDescriptor) ? samplingRate : 1.0f); float upper = hint->UpperBound * (LADSPA_IS_HINT_SAMPLE_RATE (hint->HintDescriptor) ? samplingRate : 1.0f); if (LADSPA_IS_HINT_HAS_DEFAULT (hint->HintDescriptor)) { if (LADSPA_IS_HINT_DEFAULT_0 (hint->HintDescriptor)) { normalized [i] = 0.0f; params [i] = 0.0f; } if (LADSPA_IS_HINT_DEFAULT_1 (hint->HintDescriptor)) { normalized [i] = 1.0f; params [i] = 1.0f; } if (LADSPA_IS_HINT_DEFAULT_100 (hint->HintDescriptor)) { normalized [i] = 100.0f; params [i] = 0.5f; } if (LADSPA_IS_HINT_DEFAULT_440 (hint->HintDescriptor)) { normalized [i] = 440.0f; params [i] = 0.5f; } if (LADSPA_IS_HINT_BOUNDED_BELOW(hint->HintDescriptor) && LADSPA_IS_HINT_DEFAULT_MINIMUM (hint->HintDescriptor)) { normalized [i] = lower; params [i] = 0.0f; } if (LADSPA_IS_HINT_BOUNDED_BELOW(hint->HintDescriptor) && LADSPA_IS_HINT_DEFAULT_MINIMUM (hint->HintDescriptor)) { normalized [i] = lower; params [i] = 0.0f; } if (LADSPA_IS_HINT_BOUNDED_ABOVE(hint->HintDescriptor) && LADSPA_IS_HINT_DEFAULT_MAXIMUM (hint->HintDescriptor)) { normalized [i] = upper; params [i] = 1.0f; } if (LADSPA_IS_HINT_BOUNDED_BELOW(hint->HintDescriptor)) { if (LADSPA_IS_HINT_LOGARITHMIC(hint->HintDescriptor) && lower > 0.0f && upper > 0.0f) { if (LADSPA_IS_HINT_DEFAULT_LOW(hint->HintDescriptor)) { normalized [i] = expf(logf(lower) * 0.75f + logf(upper) * 0.25f); params [i] = 0.25f; } else if (LADSPA_IS_HINT_DEFAULT_MIDDLE(hint->HintDescriptor)) { normalized [i] = expf(logf(lower) * 0.5f + logf(upper) * 0.5f); params [i] = 0.5f; } else if (LADSPA_IS_HINT_DEFAULT_HIGH(hint->HintDescriptor)) { normalized [i] = expf(logf(lower) * 0.25f + logf(upper) * 0.75f); params [i] = 0.75f; } } else { if (LADSPA_IS_HINT_DEFAULT_LOW(hint->HintDescriptor)) { normalized [i] = lower * 0.75f + upper * 0.25f; params [i] = 0.25f; } else if (LADSPA_IS_HINT_DEFAULT_MIDDLE(hint->HintDescriptor)) { normalized [i] = lower * 0.5f + upper * 0.5f; params [i] = 0.5f; } else if (LADSPA_IS_HINT_DEFAULT_HIGH(hint->HintDescriptor)) { normalized [i] = lower * 0.25f + upper * 0.75f; params [i] = 0.75f; } } } } else { normalized [i] = 0.0f; params [i] = 0.0f; } } }
static av_cold int init(AVFilterContext *ctx) { LADSPAContext *s = ctx->priv; LADSPA_Descriptor_Function descriptor_fn; const LADSPA_Descriptor *desc; LADSPA_PortDescriptor pd; AVFilterPad pad = { NULL }; char *p, *arg, *saveptr = NULL; unsigned long nb_ports; int i; if (!s->dl_name) { av_log(ctx, AV_LOG_ERROR, "No plugin name provided\n"); return AVERROR(EINVAL); } if (s->dl_name[0] == '/' || s->dl_name[0] == '.') { // argument is a path s->dl_handle = dlopen(s->dl_name, RTLD_LOCAL|RTLD_NOW); } else { // argument is a shared object name char *paths = av_strdup(getenv("LADSPA_PATH")); const char *separator = ":"; if (paths) { p = paths; while ((arg = av_strtok(p, separator, &saveptr)) && !s->dl_handle) { s->dl_handle = try_load(arg, s->dl_name); p = NULL; } } av_free(paths); if (!s->dl_handle && (paths = av_asprintf("%s/.ladspa/lib", getenv("HOME")))) { s->dl_handle = try_load(paths, s->dl_name); av_free(paths); } if (!s->dl_handle) s->dl_handle = try_load("/usr/local/lib/ladspa", s->dl_name); if (!s->dl_handle) s->dl_handle = try_load("/usr/lib/ladspa", s->dl_name); } if (!s->dl_handle) { av_log(ctx, AV_LOG_ERROR, "Failed to load '%s'\n", s->dl_name); return AVERROR(EINVAL); } descriptor_fn = dlsym(s->dl_handle, "ladspa_descriptor"); if (!descriptor_fn) { av_log(ctx, AV_LOG_ERROR, "Could not find ladspa_descriptor: %s\n", dlerror()); return AVERROR(EINVAL); } // Find the requested plugin, or list plugins if (!s->plugin) { av_log(ctx, AV_LOG_INFO, "The '%s' library contains the following plugins:\n", s->dl_name); av_log(ctx, AV_LOG_INFO, "I = Input Channels\n"); av_log(ctx, AV_LOG_INFO, "O = Output Channels\n"); av_log(ctx, AV_LOG_INFO, "I:O %-25s %s\n", "Plugin", "Description"); av_log(ctx, AV_LOG_INFO, "\n"); for (i = 0; desc = descriptor_fn(i); i++) { unsigned long inputs = 0, outputs = 0; count_ports(desc, &inputs, &outputs); av_log(ctx, AV_LOG_INFO, "%lu:%lu %-25s %s\n", inputs, outputs, desc->Label, av_x_if_null(desc->Name, "?")); av_log(ctx, AV_LOG_VERBOSE, "Maker: %s\n", av_x_if_null(desc->Maker, "?")); av_log(ctx, AV_LOG_VERBOSE, "Copyright: %s\n", av_x_if_null(desc->Copyright, "?")); } return AVERROR_EXIT; } else { for (i = 0;; i++) { desc = descriptor_fn(i); if (!desc) { av_log(ctx, AV_LOG_ERROR, "Could not find plugin: %s\n", s->plugin); return AVERROR(EINVAL); } if (desc->Label && !strcmp(desc->Label, s->plugin)) break; } } s->desc = desc; nb_ports = desc->PortCount; s->ipmap = av_calloc(nb_ports, sizeof(*s->ipmap)); s->opmap = av_calloc(nb_ports, sizeof(*s->opmap)); s->icmap = av_calloc(nb_ports, sizeof(*s->icmap)); s->ocmap = av_calloc(nb_ports, sizeof(*s->ocmap)); s->ictlv = av_calloc(nb_ports, sizeof(*s->ictlv)); s->octlv = av_calloc(nb_ports, sizeof(*s->octlv)); s->ctl_needs_value = av_calloc(nb_ports, sizeof(*s->ctl_needs_value)); if (!s->ipmap || !s->opmap || !s->icmap || !s->ocmap || !s->ictlv || !s->octlv || !s->ctl_needs_value) return AVERROR(ENOMEM); for (i = 0; i < nb_ports; i++) { pd = desc->PortDescriptors[i]; if (LADSPA_IS_PORT_AUDIO(pd)) { if (LADSPA_IS_PORT_INPUT(pd)) { s->ipmap[s->nb_inputs] = i; s->nb_inputs++; } else if (LADSPA_IS_PORT_OUTPUT(pd)) { s->opmap[s->nb_outputs] = i; s->nb_outputs++; } } else if (LADSPA_IS_PORT_CONTROL(pd)) { if (LADSPA_IS_PORT_INPUT(pd)) { s->icmap[s->nb_inputcontrols] = i; if (LADSPA_IS_HINT_HAS_DEFAULT(desc->PortRangeHints[i].HintDescriptor)) set_default_ctl_value(s, s->nb_inputcontrols, s->icmap, s->ictlv); else s->ctl_needs_value[s->nb_inputcontrols] = 1; s->nb_inputcontrols++; } else if (LADSPA_IS_PORT_OUTPUT(pd)) { s->ocmap[s->nb_outputcontrols] = i; s->nb_outputcontrols++; } } } // List Control Ports if "help" is specified if (s->options && !strcmp(s->options, "help")) { if (!s->nb_inputcontrols) { av_log(ctx, AV_LOG_INFO, "The '%s' plugin does not have any input controls.\n", desc->Label); } else { av_log(ctx, AV_LOG_INFO, "The '%s' plugin has the following input controls:\n", desc->Label); for (i = 0; i < s->nb_inputcontrols; i++) print_ctl_info(ctx, AV_LOG_INFO, s, i, s->icmap, s->ictlv, 0); } return AVERROR_EXIT; } // Parse control parameters p = s->options; while (s->options) { LADSPA_Data val; int ret; if (!(arg = av_strtok(p, "|", &saveptr))) break; p = NULL; if (sscanf(arg, "c%d=%f", &i, &val) != 2) { av_log(ctx, AV_LOG_ERROR, "Invalid syntax.\n"); return AVERROR(EINVAL); } if ((ret = set_control(ctx, i, val)) < 0) return ret; s->ctl_needs_value[i] = 0; } // Check if any controls are not set for (i = 0; i < s->nb_inputcontrols; i++) { if (s->ctl_needs_value[i]) { av_log(ctx, AV_LOG_ERROR, "Control c%d must be set.\n", i); print_ctl_info(ctx, AV_LOG_ERROR, s, i, s->icmap, s->ictlv, 0); return AVERROR(EINVAL); } } pad.type = AVMEDIA_TYPE_AUDIO; if (s->nb_inputs) { pad.name = av_asprintf("in0:%s%lu", desc->Label, s->nb_inputs); if (!pad.name) return AVERROR(ENOMEM); pad.filter_frame = filter_frame; pad.config_props = config_input; if (ff_insert_inpad(ctx, ctx->nb_inputs, &pad) < 0) { av_freep(&pad.name); return AVERROR(ENOMEM); } } av_log(ctx, AV_LOG_DEBUG, "ports: %lu\n", nb_ports); av_log(ctx, AV_LOG_DEBUG, "inputs: %lu outputs: %lu\n", s->nb_inputs, s->nb_outputs); av_log(ctx, AV_LOG_DEBUG, "input controls: %lu output controls: %lu\n", s->nb_inputcontrols, s->nb_outputcontrols); return 0; }
LADSPA_Data plugin_desc_get_default_control_value (plugin_desc_t * pd, unsigned long port_index, guint32 sample_rate) { LADSPA_Data upper, lower; LADSPA_PortRangeHintDescriptor hint_descriptor; hint_descriptor = pd->port_range_hints[port_index].HintDescriptor; /* set upper and lower, possibly adjusted to the sample rate */ if (LADSPA_IS_HINT_SAMPLE_RATE(hint_descriptor)) { upper = pd->port_range_hints[port_index].UpperBound * (LADSPA_Data) sample_rate; lower = pd->port_range_hints[port_index].LowerBound * (LADSPA_Data) sample_rate; } else { upper = pd->port_range_hints[port_index].UpperBound; lower = pd->port_range_hints[port_index].LowerBound; } if (LADSPA_IS_HINT_LOGARITHMIC(hint_descriptor)) { if (lower < FLT_EPSILON) lower = FLT_EPSILON; } if (LADSPA_IS_HINT_HAS_DEFAULT(hint_descriptor)) { if (LADSPA_IS_HINT_DEFAULT_MINIMUM(hint_descriptor)) { return lower; } else if (LADSPA_IS_HINT_DEFAULT_LOW(hint_descriptor)) { if (LADSPA_IS_HINT_LOGARITHMIC(hint_descriptor)) { return exp(log(lower) * 0.75 + log(upper) * 0.25); } else { return lower * 0.75 + upper * 0.25; } } else if (LADSPA_IS_HINT_DEFAULT_MIDDLE(hint_descriptor)) { if (LADSPA_IS_HINT_LOGARITHMIC(hint_descriptor)) { return exp(log(lower) * 0.5 + log(upper) * 0.5); } else { return lower * 0.5 + upper * 0.5; } } else if (LADSPA_IS_HINT_DEFAULT_HIGH(hint_descriptor)) { if (LADSPA_IS_HINT_LOGARITHMIC(hint_descriptor)) { return exp(log(lower) * 0.25 + log(upper) * 0.75); } else { return lower * 0.25 + upper * 0.75; } } else if (LADSPA_IS_HINT_DEFAULT_MAXIMUM(hint_descriptor)) { return upper; } else if (LADSPA_IS_HINT_DEFAULT_0(hint_descriptor)) { return 0.0; } else if (LADSPA_IS_HINT_DEFAULT_1(hint_descriptor)) { if (LADSPA_IS_HINT_SAMPLE_RATE(hint_descriptor)) { return (LADSPA_Data) sample_rate; } else { return 1.0; } } else if (LADSPA_IS_HINT_DEFAULT_100(hint_descriptor)) { if (LADSPA_IS_HINT_SAMPLE_RATE(hint_descriptor)) { return 100.0 * (LADSPA_Data) sample_rate; } else { return 100.0; } } else if (LADSPA_IS_HINT_DEFAULT_440(hint_descriptor)) { if (LADSPA_IS_HINT_SAMPLE_RATE(hint_descriptor)) { return 440.0 * (LADSPA_Data) sample_rate; } else { return 440.0; } } } else { /* try and find a reasonable default */ if (LADSPA_IS_HINT_BOUNDED_BELOW(hint_descriptor)) { return lower; } else if (LADSPA_IS_HINT_BOUNDED_ABOVE(hint_descriptor)) { return upper; } } return 0.0; }
static GParamSpec * gst_ladspa_class_get_param_spec (GstLADSPAClass * klass, gint portnum) { LADSPA_Descriptor *desc; GParamSpec *ret; gchar *name; gint hintdesc, perms; gfloat lower, upper, def; desc = klass->descriptor; name = gst_ladspa_class_get_param_name (klass, portnum); perms = G_PARAM_READABLE; if (LADSPA_IS_PORT_INPUT (desc->PortDescriptors[portnum])) perms |= G_PARAM_WRITABLE | G_PARAM_CONSTRUCT; if (LADSPA_IS_PORT_CONTROL (desc->PortDescriptors[portnum])) perms |= GST_PARAM_CONTROLLABLE; /* short name for hint descriptor */ hintdesc = desc->PortRangeHints[portnum].HintDescriptor; if (LADSPA_IS_HINT_TOGGLED (hintdesc)) { ret = g_param_spec_boolean (name, name, name, FALSE, perms); g_free (name); return ret; } if (LADSPA_IS_HINT_BOUNDED_BELOW (hintdesc)) lower = desc->PortRangeHints[portnum].LowerBound; else lower = -G_MAXFLOAT; if (LADSPA_IS_HINT_BOUNDED_ABOVE (hintdesc)) upper = desc->PortRangeHints[portnum].UpperBound; else upper = G_MAXFLOAT; if (LADSPA_IS_HINT_SAMPLE_RATE (hintdesc)) { /* FIXME! */ lower *= 44100; upper *= 44100; } if (LADSPA_IS_HINT_INTEGER (hintdesc)) { lower = CLAMP (lower, G_MININT, G_MAXINT); upper = CLAMP (upper, G_MININT, G_MAXINT); } /* default to lower bound */ def = lower; #ifdef LADSPA_IS_HINT_HAS_DEFAULT if (LADSPA_IS_HINT_HAS_DEFAULT (hintdesc)) { if (LADSPA_IS_HINT_DEFAULT_0 (hintdesc)) def = 0.0; else if (LADSPA_IS_HINT_DEFAULT_1 (hintdesc)) def = 1.0; else if (LADSPA_IS_HINT_DEFAULT_100 (hintdesc)) def = 100.0; else if (LADSPA_IS_HINT_DEFAULT_440 (hintdesc)) def = 440.0; if (LADSPA_IS_HINT_DEFAULT_MINIMUM (hintdesc)) def = lower; else if (LADSPA_IS_HINT_DEFAULT_MAXIMUM (hintdesc)) def = upper; else if (LADSPA_IS_HINT_LOGARITHMIC (hintdesc)) { if (LADSPA_IS_HINT_DEFAULT_LOW (hintdesc)) def = exp (0.75 * log (lower) + 0.25 * log (upper)); else if (LADSPA_IS_HINT_DEFAULT_MIDDLE (hintdesc)) def = exp (0.5 * log (lower) + 0.5 * log (upper)); else if (LADSPA_IS_HINT_DEFAULT_HIGH (hintdesc)) def = exp (0.25 * log (lower) + 0.75 * log (upper)); } else { if (LADSPA_IS_HINT_DEFAULT_LOW (hintdesc)) def = 0.75 * lower + 0.25 * upper; else if (LADSPA_IS_HINT_DEFAULT_MIDDLE (hintdesc)) def = 0.5 * lower + 0.5 * upper; else if (LADSPA_IS_HINT_DEFAULT_HIGH (hintdesc)) def = 0.25 * lower + 0.75 * upper; } } #endif /* LADSPA_IS_HINT_HAS_DEFAULT */ if (lower > upper) { gfloat tmp; /* silently swap */ tmp = lower; lower = upper; upper = tmp; } def = CLAMP (def, lower, upper); if (LADSPA_IS_HINT_INTEGER (hintdesc)) { ret = g_param_spec_int (name, name, name, lower, upper, def, perms); } else { ret = g_param_spec_float (name, name, name, lower, upper, def, perms); } g_free (name); return ret; }
int lp_ladspa_knob_float::init(const LADSPA_Descriptor *descriptor, unsigned long port, int samplerate) { LADSPA_Data f_val, f_low, f_high; if(descriptor == 0){ std::cerr << "lp_ladspa_slider_int::" << __FUNCTION__ << ": pdescriptor is Null\n"; return -1; } pv_samplerate = samplerate; LADSPA_PortRangeHintDescriptor hints; hints = descriptor->PortRangeHints[port].HintDescriptor; LADSPA_PortRangeHint range_hints; range_hints = descriptor->PortRangeHints[port]; if(LADSPA_IS_HINT_BOUNDED_BELOW(hints)){ f_val = range_hints.LowerBound; if(LADSPA_IS_HINT_SAMPLE_RATE(hints) && f_val != 0){ f_val = f_val * (LADSPA_Data)pv_samplerate; } pv_low_val = (double)f_val; f_low = f_val; }else{ // Set a default val pv_low_val = pv_default_low_val; f_low = (LADSPA_Data)pv_default_low_val; } if(LADSPA_IS_HINT_BOUNDED_ABOVE(hints)){ f_val = range_hints.UpperBound; if(LADSPA_IS_HINT_SAMPLE_RATE(hints) && f_val != 0){ f_val = f_val * (LADSPA_Data)pv_samplerate; } pv_high_val = (double)f_val; f_high = f_val; }else{ // Set a default val pv_high_val = pv_default_high_val; f_high = (LADSPA_Data)pv_default_high_val; } if(LADSPA_IS_HINT_LOGARITHMIC(hints)){ pv_is_log = true; // verifiy we have somthing else than 0 if(pv_low_val == 0){ pv_low_val = pv_default_low_val; } if(pv_high_val == 0){ pv_high_val = pv_default_high_val; } // Set the log scale kb_val->setScaleEngine(log10_scale_engine); kb_val->setScale(pv_low_val, pv_high_val); // Set this range to the spinbox sp_val->setRange(pv_low_val, pv_high_val); // Calcule the slider range double d_low, d_high; d_low = log10(pv_low_val); d_high = log10(pv_high_val); // Set range to the slider kb_val->setRange(d_low, d_high); }else{ // Set range to the slider and spinbox kb_val->setRange(pv_low_val, pv_high_val); sp_val->setRange(pv_low_val, pv_high_val); } // Store the range in f_val's f_low = (LADSPA_Data)pv_low_val; f_high = (LADSPA_Data)pv_high_val; // Default values if(LADSPA_IS_HINT_HAS_DEFAULT(hints)){ if(LADSPA_IS_HINT_DEFAULT_MINIMUM(hints)){ pv_def_val = pv_low_val; } if(LADSPA_IS_HINT_DEFAULT_MAXIMUM(hints)){ pv_def_val = pv_high_val; } if(LADSPA_IS_HINT_DEFAULT_LOW(hints)){ if(LADSPA_IS_HINT_LOGARITHMIC(hints)){ f_val = exp(log(f_low)*0.75f + log(f_high)*0.25f); }else{ f_val = (f_low*0.75f + f_high*0.25f); } } if(LADSPA_IS_HINT_DEFAULT_MIDDLE(hints)){ if(LADSPA_IS_HINT_LOGARITHMIC(hints)){ f_val = exp(log(f_low)*0.5f + log(f_high)*0.5f); }else{ f_val = (f_low*0.5f + f_high*0.5f); } } if(LADSPA_IS_HINT_DEFAULT_HIGH(hints)){ if(LADSPA_IS_HINT_LOGARITHMIC(hints)){ f_val = exp(log(f_low)*0.25f + log(f_high)*0.75f); }else{ f_val = (f_low*0.25f + f_high*0.75f); } } if(LADSPA_IS_HINT_DEFAULT_0(hints)){ f_val = 0.0f; } if(LADSPA_IS_HINT_DEFAULT_1(hints)){ f_val = 1.0f; } if(LADSPA_IS_HINT_DEFAULT_100(hints)){ f_val = 100.0f; } if(LADSPA_IS_HINT_DEFAULT_440(hints)){ f_val = 440.0f; } // Set default value pv_def_val = (double)f_val; }else{ pv_def_val = pv_low_val; } txt_name->setText(descriptor->PortNames[port]); // set the middle value set_def_val(); emit_changed(pv_def_val); return 0; }
int pa__init(pa_module*m) { struct userdata *u; pa_sample_spec ss; pa_channel_map map; pa_modargs *ma; char *t; pa_sink *master; pa_sink_input_new_data sink_input_data; pa_sink_new_data sink_data; const char *plugin, *label; LADSPA_Descriptor_Function descriptor_func; const char *e, *cdata; const LADSPA_Descriptor *d; unsigned long input_port, output_port, p, j, n_control; unsigned c; pa_bool_t *use_default = NULL; pa_assert(m); pa_assert_cc(sizeof(LADSPA_Data) == sizeof(float)); if (!(ma = pa_modargs_new(m->argument, valid_modargs))) { pa_log("Failed to parse module arguments."); goto fail; } if (!(master = pa_namereg_get(m->core, pa_modargs_get_value(ma, "master", NULL), PA_NAMEREG_SINK))) { pa_log("Master sink not found"); goto fail; } ss = master->sample_spec; ss.format = PA_SAMPLE_FLOAT32; map = master->channel_map; if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_DEFAULT) < 0) { pa_log("Invalid sample format specification or channel map"); goto fail; } if (!(plugin = pa_modargs_get_value(ma, "plugin", NULL))) { pa_log("Missing LADSPA plugin name"); goto fail; } if (!(label = pa_modargs_get_value(ma, "label", NULL))) { pa_log("Missing LADSPA plugin label"); goto fail; } cdata = pa_modargs_get_value(ma, "control", NULL); u = pa_xnew0(struct userdata, 1); u->module = m; m->userdata = u; u->memblockq = pa_memblockq_new(0, MEMBLOCKQ_MAXLENGTH, 0, pa_frame_size(&ss), 1, 1, 0, NULL); if (!(e = getenv("LADSPA_PATH"))) e = LADSPA_PATH; /* FIXME: This is not exactly thread safe */ t = pa_xstrdup(lt_dlgetsearchpath()); lt_dlsetsearchpath(e); m->dl = lt_dlopenext(plugin); lt_dlsetsearchpath(t); pa_xfree(t); if (!m->dl) { pa_log("Failed to load LADSPA plugin: %s", lt_dlerror()); goto fail; } if (!(descriptor_func = (LADSPA_Descriptor_Function) pa_load_sym(m->dl, NULL, "ladspa_descriptor"))) { pa_log("LADSPA module lacks ladspa_descriptor() symbol."); goto fail; } for (j = 0;; j++) { if (!(d = descriptor_func(j))) { pa_log("Failed to find plugin label '%s' in plugin '%s'.", label, plugin); goto fail; } if (strcmp(d->Label, label) == 0) break; } u->descriptor = d; pa_log_debug("Module: %s", plugin); pa_log_debug("Label: %s", d->Label); pa_log_debug("Unique ID: %lu", d->UniqueID); pa_log_debug("Name: %s", d->Name); pa_log_debug("Maker: %s", d->Maker); pa_log_debug("Copyright: %s", d->Copyright); input_port = output_port = (unsigned long) -1; n_control = 0; for (p = 0; p < d->PortCount; p++) { if (LADSPA_IS_PORT_INPUT(d->PortDescriptors[p]) && LADSPA_IS_PORT_AUDIO(d->PortDescriptors[p])) { if (strcmp(d->PortNames[p], "Input") == 0) { pa_assert(input_port == (unsigned long) -1); input_port = p; } else { pa_log("Found audio input port on plugin we cannot handle: %s", d->PortNames[p]); goto fail; } } else if (LADSPA_IS_PORT_OUTPUT(d->PortDescriptors[p]) && LADSPA_IS_PORT_AUDIO(d->PortDescriptors[p])) { if (strcmp(d->PortNames[p], "Output") == 0) { pa_assert(output_port == (unsigned long) -1); output_port = p; } else { pa_log("Found audio output port on plugin we cannot handle: %s", d->PortNames[p]); goto fail; } } else if (LADSPA_IS_PORT_INPUT(d->PortDescriptors[p]) && LADSPA_IS_PORT_CONTROL(d->PortDescriptors[p])) n_control++; else { pa_assert(LADSPA_IS_PORT_OUTPUT(d->PortDescriptors[p]) && LADSPA_IS_PORT_CONTROL(d->PortDescriptors[p])); pa_log_debug("Ignored control output port \"%s\".", d->PortNames[p]); } } if ((input_port == (unsigned long) -1) || (output_port == (unsigned long) -1)) { pa_log("Failed to identify input and output ports. " "Right now this module can only deal with plugins which provide an 'Input' and an 'Output' audio port. " "Patches welcome!"); goto fail; } u->block_size = pa_frame_align(pa_mempool_block_size_max(m->core->mempool), &ss); u->input = (LADSPA_Data*) pa_xnew(uint8_t, (unsigned) u->block_size); if (LADSPA_IS_INPLACE_BROKEN(d->Properties)) u->output = (LADSPA_Data*) pa_xnew(uint8_t, (unsigned) u->block_size); else u->output = u->input; u->channels = ss.channels; for (c = 0; c < ss.channels; c++) { if (!(u->handle[c] = d->instantiate(d, ss.rate))) { pa_log("Failed to instantiate plugin %s with label %s for channel %i", plugin, d->Label, c); goto fail; } d->connect_port(u->handle[c], input_port, u->input); d->connect_port(u->handle[c], output_port, u->output); } if (!cdata && n_control > 0) { pa_log("This plugin requires specification of %lu control parameters.", n_control); goto fail; } if (n_control > 0) { const char *state = NULL; char *k; unsigned long h; u->control = pa_xnew(LADSPA_Data, (unsigned) n_control); use_default = pa_xnew(pa_bool_t, (unsigned) n_control); p = 0; while ((k = pa_split(cdata, ",", &state)) && p < n_control) { double f; if (*k == 0) { use_default[p++] = TRUE; pa_xfree(k); continue; } if (pa_atod(k, &f) < 0) { pa_log("Failed to parse control value '%s'", k); pa_xfree(k); goto fail; } pa_xfree(k); use_default[p] = FALSE; u->control[p++] = (LADSPA_Data) f; } /* The previous loop doesn't take the last control value into account if it is left empty, so we do it here. */ if (*cdata == 0 || cdata[strlen(cdata) - 1] == ',') { if (p < n_control) use_default[p] = TRUE; p++; } if (p > n_control || k) { pa_log("Too many control values passed, %lu expected.", n_control); pa_xfree(k); goto fail; } if (p < n_control) { pa_log("Not enough control values passed, %lu expected, %lu passed.", n_control, p); goto fail; } h = 0; for (p = 0; p < d->PortCount; p++) { LADSPA_PortRangeHintDescriptor hint = d->PortRangeHints[p].HintDescriptor; if (!LADSPA_IS_PORT_CONTROL(d->PortDescriptors[p])) continue; if (LADSPA_IS_PORT_OUTPUT(d->PortDescriptors[p])) { for (c = 0; c < ss.channels; c++) d->connect_port(u->handle[c], p, &u->control_out); continue; } pa_assert(h < n_control); if (use_default[h]) { LADSPA_Data lower, upper; if (!LADSPA_IS_HINT_HAS_DEFAULT(hint)) { pa_log("Control port value left empty but plugin defines no default."); goto fail; } lower = d->PortRangeHints[p].LowerBound; upper = d->PortRangeHints[p].UpperBound; if (LADSPA_IS_HINT_SAMPLE_RATE(hint)) { lower *= (LADSPA_Data) ss.rate; upper *= (LADSPA_Data) ss.rate; } switch (hint & LADSPA_HINT_DEFAULT_MASK) { case LADSPA_HINT_DEFAULT_MINIMUM: u->control[h] = lower; break; case LADSPA_HINT_DEFAULT_MAXIMUM: u->control[h] = upper; break; case LADSPA_HINT_DEFAULT_LOW: if (LADSPA_IS_HINT_LOGARITHMIC(hint)) u->control[h] = (LADSPA_Data) exp(log(lower) * 0.75 + log(upper) * 0.25); else u->control[h] = (LADSPA_Data) (lower * 0.75 + upper * 0.25); break; case LADSPA_HINT_DEFAULT_MIDDLE: if (LADSPA_IS_HINT_LOGARITHMIC(hint)) u->control[h] = (LADSPA_Data) exp(log(lower) * 0.5 + log(upper) * 0.5); else u->control[h] = (LADSPA_Data) (lower * 0.5 + upper * 0.5); break; case LADSPA_HINT_DEFAULT_HIGH: if (LADSPA_IS_HINT_LOGARITHMIC(hint)) u->control[h] = (LADSPA_Data) exp(log(lower) * 0.25 + log(upper) * 0.75); else u->control[h] = (LADSPA_Data) (lower * 0.25 + upper * 0.75); break; case LADSPA_HINT_DEFAULT_0: u->control[h] = 0; break; case LADSPA_HINT_DEFAULT_1: u->control[h] = 1; break; case LADSPA_HINT_DEFAULT_100: u->control[h] = 100; break; case LADSPA_HINT_DEFAULT_440: u->control[h] = 440; break; default: pa_assert_not_reached(); } } if (LADSPA_IS_HINT_INTEGER(hint)) u->control[h] = roundf(u->control[h]); pa_log_debug("Binding %f to port %s", u->control[h], d->PortNames[p]); for (c = 0; c < ss.channels; c++) d->connect_port(u->handle[c], p, &u->control[h]); h++; } pa_assert(h == n_control); } if (d->activate) for (c = 0; c < u->channels; c++) d->activate(u->handle[c]); /* Create sink */ pa_sink_new_data_init(&sink_data); sink_data.driver = __FILE__; sink_data.module = m; if (!(sink_data.name = pa_xstrdup(pa_modargs_get_value(ma, "sink_name", NULL)))) sink_data.name = pa_sprintf_malloc("%s.ladspa", master->name); pa_sink_new_data_set_sample_spec(&sink_data, &ss); pa_sink_new_data_set_channel_map(&sink_data, &map); pa_proplist_sets(sink_data.proplist, PA_PROP_DEVICE_MASTER_DEVICE, master->name); pa_proplist_sets(sink_data.proplist, PA_PROP_DEVICE_CLASS, "filter"); pa_proplist_sets(sink_data.proplist, "device.ladspa.module", plugin); pa_proplist_sets(sink_data.proplist, "device.ladspa.label", d->Label); pa_proplist_sets(sink_data.proplist, "device.ladspa.name", d->Name); pa_proplist_sets(sink_data.proplist, "device.ladspa.maker", d->Maker); pa_proplist_sets(sink_data.proplist, "device.ladspa.copyright", d->Copyright); pa_proplist_setf(sink_data.proplist, "device.ladspa.unique_id", "%lu", (unsigned long) d->UniqueID); if (pa_modargs_get_proplist(ma, "sink_properties", sink_data.proplist, PA_UPDATE_REPLACE) < 0) { pa_log("Invalid properties"); pa_sink_new_data_done(&sink_data); goto fail; } if ((u->auto_desc = !pa_proplist_contains(sink_data.proplist, PA_PROP_DEVICE_DESCRIPTION))) { const char *z; z = pa_proplist_gets(master->proplist, PA_PROP_DEVICE_DESCRIPTION); pa_proplist_setf(sink_data.proplist, PA_PROP_DEVICE_DESCRIPTION, "LADSPA Plugin %s on %s", d->Name, z ? z : master->name); } u->sink = pa_sink_new(m->core, &sink_data, PA_SINK_HW_MUTE_CTRL|PA_SINK_HW_VOLUME_CTRL|PA_SINK_DECIBEL_VOLUME| (master->flags & (PA_SINK_LATENCY|PA_SINK_DYNAMIC_LATENCY))); pa_sink_new_data_done(&sink_data); if (!u->sink) { pa_log("Failed to create sink."); goto fail; } u->sink->parent.process_msg = sink_process_msg_cb; u->sink->set_state = sink_set_state_cb; u->sink->update_requested_latency = sink_update_requested_latency_cb; u->sink->request_rewind = sink_request_rewind_cb; u->sink->set_volume = sink_set_volume_cb; u->sink->set_mute = sink_set_mute_cb; u->sink->userdata = u; pa_sink_set_asyncmsgq(u->sink, master->asyncmsgq); /* Create sink input */ pa_sink_input_new_data_init(&sink_input_data); sink_input_data.driver = __FILE__; sink_input_data.module = m; sink_input_data.sink = master; pa_proplist_sets(sink_input_data.proplist, PA_PROP_MEDIA_NAME, "LADSPA Stream"); pa_proplist_sets(sink_input_data.proplist, PA_PROP_MEDIA_ROLE, "filter"); pa_sink_input_new_data_set_sample_spec(&sink_input_data, &ss); pa_sink_input_new_data_set_channel_map(&sink_input_data, &map); pa_sink_input_new(&u->sink_input, m->core, &sink_input_data); pa_sink_input_new_data_done(&sink_input_data); if (!u->sink_input) goto fail; u->sink_input->pop = sink_input_pop_cb; u->sink_input->process_rewind = sink_input_process_rewind_cb; u->sink_input->update_max_rewind = sink_input_update_max_rewind_cb; u->sink_input->update_max_request = sink_input_update_max_request_cb; u->sink_input->update_sink_latency_range = sink_input_update_sink_latency_range_cb; u->sink_input->update_sink_fixed_latency = sink_input_update_sink_fixed_latency_cb; u->sink_input->kill = sink_input_kill_cb; u->sink_input->attach = sink_input_attach_cb; u->sink_input->detach = sink_input_detach_cb; u->sink_input->state_change = sink_input_state_change_cb; u->sink_input->may_move_to = sink_input_may_move_to_cb; u->sink_input->moving = sink_input_moving_cb; u->sink_input->volume_changed = sink_input_volume_changed_cb; u->sink_input->mute_changed = sink_input_mute_changed_cb; u->sink_input->userdata = u; pa_sink_put(u->sink); pa_sink_input_put(u->sink_input); pa_modargs_free(ma); pa_xfree(use_default); return 0; fail: if (ma) pa_modargs_free(ma); pa_xfree(use_default); pa__done(m); return -1; }
bool qtractorLadspaPluginParam::isDefaultValue (void) const { return LADSPA_IS_HINT_HAS_DEFAULT(m_portHints); }