plugin.c

Aqualung is an advanced music player primarily targeted for the GNU/Linux operating system, but als

	} else {
		instance->is_mono = 0;
		instance->handle = instance->descriptor->instantiate(instance->descriptor, out_SR);
		instance->handle2 = NULL;
	}

	instance->is_restored = 0;
	instance->is_bypassed = 1;
	instance->shift_pressed = 0;
	instance->window = NULL;
	instance->bypass_button = NULL;
	instance->trashlist = trashlist_new();

	return instance;
}


void
connect_port(plugin_instance * instance) {

	unsigned long port;
	unsigned long inputs = 0, outputs = 0;
	const LADSPA_Descriptor * plugin = instance->descriptor;

	for (port = 0; port < plugin->PortCount; ++port) {

		if (LADSPA_IS_PORT_CONTROL(plugin->PortDescriptors[port])) {
			if (port < MAX_KNOBS) {
				plugin->connect_port(instance->handle, port,
						     &(instance->knobs[port]));
				if (instance->handle2)
					plugin->connect_port(instance->handle2, port,
							     &(instance->knobs[port]));
			} else {
				fprintf(stderr, "impossible: control port count out of range\n");
			}

		} else if (LADSPA_IS_PORT_AUDIO(plugin->PortDescriptors[port])) {

			if (LADSPA_IS_PORT_INPUT(plugin->PortDescriptors[port])) {
				if (inputs == 0) {
					plugin->connect_port(instance->handle, port, l_buf);
					if (instance->handle2)
						plugin->connect_port(instance->handle2, port, r_buf);
				} else if (inputs == 1 && !instance->is_mono) {
					plugin->connect_port(instance->handle, port, r_buf);
				} else {
					fprintf(stderr, "impossible: input port count out of range\n");
				}
				inputs++;

			} else if (LADSPA_IS_PORT_OUTPUT(plugin->PortDescriptors[port])) {
				if (outputs == 0) {
					plugin->connect_port(instance->handle, port, l_buf);
					if (instance->handle2)
						plugin->connect_port(instance->handle2, port, r_buf);
				} else if (outputs == 1 && !instance->is_mono) {
					plugin->connect_port(instance->handle, port, r_buf);
				} else {
					fprintf(stderr, "impossible: output port count out of range\n");
				}
				outputs++;
			}
		}
	}
}


void
activate(plugin_instance * instance) {

	const LADSPA_Descriptor * descriptor = instance->descriptor;

	if (descriptor->activate) {
		descriptor->activate(instance->handle);
		if (instance->handle2) {
			descriptor->activate(instance->handle2);
		}
	}
}


void
get_bypassed_name(plugin_instance * instance, char * str) {

	if (instance->is_bypassed) {
		snprintf(str, MAXLEN-1, "(%s)", instance->descriptor->Name);
	} else {
		strncpy(str, instance->descriptor->Name, MAXLEN-1);
	}
}


void
refresh_plugin_vect(int diff) {
	
	int i = 0, j = 0;
	GtkTreeIter iter;
	gpointer gp_instance;
	plugin_instance * plugin_vect_shadow[MAX_PLUGINS];

        while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(running_store), &iter, NULL, i) &&
		i < MAX_PLUGINS) {

		gtk_tree_model_get(GTK_TREE_MODEL(running_store), &iter, 1, &gp_instance, -1);
		plugin_vect_shadow[i] = (plugin_instance *) gp_instance;
		++i;
	}

	//spin_waitlock_s(&plugin_lock);
	while (plugin_lock)
		/*printf("plugin_lock collision 1\n")*/;
	if (diff < 0)
		n_plugins += diff;

	for (j = 0; j < i; j++) {
		while (plugin_lock)
			/*printf("plugin_lock collision 2\n")*/;
		plugin_vect[j] = plugin_vect_shadow[j];
	}

	while (plugin_lock)
		/*printf("plugin_lock collision 3\n")*/;
	if (diff >= 0)
		n_plugins += diff;
	//spin_unlock_s(&plugin_lock);
}


static gboolean
close_plugin_window(GtkWidget * widget, GdkEvent * event, gpointer data) {

        gtk_widget_hide(widget);
        return TRUE;
}


void
plugin_bypassed(GtkWidget * widget, gpointer data) {

        int i = 0;
        GtkTreeIter iter;
	char bypassed_name[MAXLEN];
	char * name;
        gpointer gp_instance;
	plugin_instance * instance = (plugin_instance *) data;

	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) {
		//spin_waitlock_s(&plugin_lock);
		instance->is_bypassed = 1;
		//spin_unlock_s(&plugin_lock);
	} else {
		//spin_waitlock_s(&plugin_lock);
		instance->is_bypassed = 0;
		//spin_unlock_s(&plugin_lock);
	}

        while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(running_store), &iter, NULL, i)) {

                gtk_tree_model_get(GTK_TREE_MODEL(running_store), &iter, 0, &name, 1, &gp_instance, -1);
		if (instance == (plugin_instance *)gp_instance) {
			get_bypassed_name(instance, bypassed_name);
			gtk_list_store_set(running_store, &iter, 0, bypassed_name, -1);
			return;
		}
		++i;
        }
}


void
plugin_btn_toggled(GtkWidget * widget, gpointer data) {

	LADSPA_Data * plugin_data = (LADSPA_Data *) data;

	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) {
		//spin_waitlock_s(&plugin_lock);
		*plugin_data = 1.0f;
		//spin_unlock_s(&plugin_lock);
	} else {
		//spin_waitlock_s(&plugin_lock);
		*plugin_data = -1.0f;
		//spin_unlock_s(&plugin_lock);
	}
}


gint
update_plugin_outputs(gpointer data) {

	plugin_instance * instance = (plugin_instance *) data;
	unsigned long k;

	//spin_waitlock_s(&plugin_lock);
	for (k = 0; k < MAX_KNOBS && k < instance->descriptor->PortCount; ++k) {
		if (LADSPA_IS_PORT_OUTPUT(instance->descriptor->PortDescriptors[k])
		    && LADSPA_IS_PORT_CONTROL(instance->descriptor->PortDescriptors[k])) {

			while (plugin_lock)
				/*printf("plugin_lock collision 4\n")*/;
			instance->adjustments[k]->value = instance->knobs[k];
		}
	}
	//spin_unlock_s(&plugin_lock);

	for (k = 0; k < MAX_KNOBS && k < instance->descriptor->PortCount; ++k) {
		if (LADSPA_IS_PORT_OUTPUT(instance->descriptor->PortDescriptors[k])
		    && LADSPA_IS_PORT_CONTROL(instance->descriptor->PortDescriptors[k])) {
			
			gtk_adjustment_value_changed(instance->adjustments[k]);
		}
	}
	return TRUE;
}


void
plugin_value_changed(GtkAdjustment * adj, gpointer data) {

	LADSPA_Data * plugin_data = (LADSPA_Data *) data;

	//spin_waitlock_s(&plugin_lock);
	*plugin_data = (LADSPA_Data) gtk_adjustment_get_value(adj);
	//spin_unlock_s(&plugin_lock);
}


void
changed_combo(GtkWidget * widget, gpointer * data) {

	optdata_t * optdata = (optdata_t *) data;
	plugin_instance * instance = optdata->instance;
	int k = optdata->index;
	
	int i = gtk_combo_box_get_active(GTK_COMBO_BOX(widget));
	LADSPA_Data value = 0.0f;

	lrdf_defaults * defs = lrdf_get_scale_values(instance->descriptor->UniqueID, k);
	value = defs->items[i].value;

	lrdf_free_setting_values(defs);

	//spin_waitlock_s(&plugin_lock);
	instance->knobs[k] = value;
	//spin_unlock_s(&plugin_lock);
}


gint
plugin_window_key_pressed(GtkWidget * widget, GdkEventKey * event, gpointer * data) {

	plugin_instance * instance = (plugin_instance *) data;

        switch (event->keyval) {
        case GDK_Shift_L:
        case GDK_Shift_R:
                instance->shift_pressed = 1;
                break;
        }

	return FALSE;
}


gint
plugin_window_key_released(GtkWidget * widget, GdkEventKey * event, gpointer * data) {

	plugin_instance * instance = (plugin_instance *) data;

        switch (event->keyval) {
        case GDK_Shift_L:
        case GDK_Shift_R:
                instance->shift_pressed = 0;
                break;
        }

	return FALSE;
}


gint
plugin_window_focus_out(GtkWidget * widget, GdkEventKey * event, gpointer * data) {

	plugin_instance * instance = (plugin_instance *) data;

	instance->shift_pressed = 0;

	return FALSE;
}


gint
plugin_scale_btn_pressed(GtkWidget * widget, GdkEventButton * event, gpointer * data) {

	btnpdata_t * btnpdata = (btnpdata_t *) data;
	GtkAdjustment * adj;

        if (event->button != 1)
                return FALSE;

	if (!btnpdata->instance->shift_pressed)
		return FALSE;

	adj = gtk_range_get_adjustment(GTK_RANGE(widget));
	//spin_waitlock_s(&plugin_lock);
	adj->value = btnpdata->start;
	//spin_unlock_s(&plugin_lock);
	gtk_adjustment_value_changed(adj);

        return TRUE;
}


void
build_plugin_window(plugin_instance * instance) {

	const LADSPA_Descriptor * plugin = instance->descriptor;
	const LADSPA_PortRangeHint * hints = plugin->PortRangeHints;
	LADSPA_Data fact, min, max, step, start, default_val;
	lrdf_defaults * defs;
	int dp;
	unsigned long k;
	int n_outs = 0;
	int n_ins = 0;
	int n_toggled = 0;
	int n_untoggled = 0;
	int n_outctl = 0;
	int n_outlat = 0;
	int n_rows = 0;
	int i = 0;

	char str_inout[32];
	char str_n[16];
	char * c;
	char maker[MAXLEN];
	GtkWidget * widget;
	GtkWidget * hbox;
	GtkWidget * vbox;
	GtkWidget * upper_hbox;
	GtkWidget * upper_vbox;

	GtkWidget * scrwin;
	GtkWidget * inner_vbox;
	GtkWidget * table = NULL; /* gcc rulez, eh? */
	GtkWidget * hseparator;
	GtkObject * adjustment;
	GtkWidget * combo;
	GList * glist;

	optdata_t * optdata;
	btnpdata_t * btnpdata;
	int j;

	GtkRequisition req;
	int max_width = 0;
	int height = 0;


	instance->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title(GTK_WINDOW(instance->window), plugin->Name);
	gtk_window_set_position(GTK_WINDOW(instance->window), GTK_WIN_POS_CENTER);
	gtk_window_set_transient_for(GTK_WINDOW(instance->window), GTK_WINDOW(fxbuilder_window));
        g_signal_connect(G_OBJECT(instance->window), "key_press_event",
			 G_CALLBACK(plugin_window_key_pressed), instance);
        g_signal_connect(G_OBJECT(instance->window), "key_release_event",
                         G_CALLBACK(plugin_window_key_released), instance);
        g_signal_connect(G_OBJECT(instance->window), "focus_out_event",
                         G_CALLBACK(plugin_window_focus_out), instance);
        gtk_widget_set_events(instance->window,
			      GDK_BUTTON_PRESS_MASK | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK);
        gtk_container_set_border_width(GTK_CONTAINER(instance->window), 5);

	vbox = gtk_vbox_new(FALSE, 3);
	gtk_container_add(GTK_CONTAINER(instance->window), vbox);

	upper_hbox = gtk_hbox_new(FALSE, 0);
	gtk_box_pack_start(GTK_BOX(vbox), upper_hbox, FALSE, TRUE, 2);

	upper_vbox = gtk_vbox_new(FALSE, 0);
	gtk_box_pack_start(GTK_BOX(upper_hbox), upper_vbox, FALSE, FALSE, 2);

	widget = gtk_label_new(plugin->Name);
	gtk_widget_set_name(widget, "plugin_name");
	hbox = gtk_hbox_new(FALSE, 0);
        gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, FALSE, 0);
	gtk_box_pack_start(GTK_BOX(upper_vbox), hbox, FALSE, FALSE, 2);

	strncpy(maker, plugin->Maker, MAXLEN-1);
	if ((c = strchr(maker, '<')) != NULL)
		*c = '\0';
	widget = gtk_label_new(maker);
	gtk_widget_set_name(widget, "plugin_maker");
	hbox = gtk_hbox_new(FALSE, 0);
        gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, FALSE, 0);
	gtk_box_pack_start(GTK_BOX(upper_vbox), hbox, FALSE, FALSE, 2);

	/* count audio I/O ports */
	for (k = 0; k < MAX_KNOBS && k < plugin->PortCount; ++k) {
		if (LADSPA_IS_PORT_CONTROL(plugin->PortDescriptors[k]))
			continue;
		if (LADSPA_IS_PORT_OUTPUT(plugin->PortDescriptors[k])) {
			++n_outs;
		} else {
			++n_ins;
		}
	}

	strcpy(str_inout, "[ ");
	if (n_ins == 1) {
		strcat(str_inout, "1 in");
	} else {
		snprintf(str_n, 15, "%d ins", n_ins);
		strcat(str_inout, str_n);
	}
	strcat(str_inout, " | ");
	if (n_outs == 1) {
		strcat(str_inout, "1 out");
	} else {
		snprintf(str_n, 15, "%d outs", n_outs);
		strcat(str_inout, str_n);
	}
	strcat(str_inout, " ]");
 
	widget = gtk_label_new(str_inout);
	hbox = gtk_hbox_new(FALSE, 0);
        gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, FALSE, 0);
	gtk_box_pack_start(GTK_BOX(upper_vbox), hbox, FALSE, FALSE, 2);

	upper_vbox = gtk_vbox_new(FALSE, 0);
	gtk_box_pack_end(GTK_BOX(upper_hbox), upper_vbox, FALSE, FALSE, 2);


	widget = gtk_toggle_button_new_with_label("BYPASS");
	gtk_widget_set_name(widget, "plugin_bypass_button");
	instance->bypass_button = widget;
	gtk_box_pack_start(GTK_BOX(upper_vbox), widget, FALSE, FALSE, 2);
	g_signal_connect(G_OBJECT(widget), "toggled", G_CALLBACK(plugin_bypassed), instance);