static void transfer (Index * source)
{
Index * dest;
GtkWidget * source_list, * dest_list;
if (source == chosen)
{
dest = avail;
source_list = chosen_list;
dest_list = avail_list;
}
else
{
dest = chosen;
source_list = avail_list;
dest_list = chosen_list;
}
gint source_rows = index_count (source);
gint dest_rows = index_count (dest);
for (gint row = 0; row < source_rows; )
{
Column * c = index_get (source, row);
if (! c->selected)
{
row ++;
continue;
}
index_delete (source, row, 1);
audgui_list_delete_rows (source_list, row, 1);
source_rows --;
index_append (dest, c);
audgui_list_insert_rows (dest_list, dest_rows, 1);
dest_rows ++;
}
}
static bool_t playlist_load_pls (const char * filename, VFSFile * file,
char * * title, Index * filenames, Index * tuples)
{
INIFile * inifile = inifile_read (file);
if (! inifile)
return FALSE;
* title = NULL;
const char * val = inifile_lookup (inifile, "playlist", "numberofentries");
if (! val)
{
inifile_destroy (inifile);
return FALSE;
}
int count = atoi (val);
for (int i = 1; i <= count; i ++)
{
SPRINTF (key, "file%d", i);
if (! (val = inifile_lookup (inifile, "playlist", key)))
continue;
char * uri = aud_construct_uri (val, filename);
if (! uri)
continue;
index_append (filenames, str_get (uri));
free (uri);
}
inifile_destroy (inifile);
return TRUE;
}
static void xspf_add_file (xmlNode * track, const gchar * filename, const gchar
* base, Index * filenames, Index * tuples)
{
xmlNode *nptr;
gchar *location = NULL;
Tuple * tuple = NULL;
for (nptr = track->children; nptr != NULL; nptr = nptr->next) {
if (nptr->type == XML_ELEMENT_NODE) {
if (!xmlStrcmp(nptr->name, (xmlChar *)"location")) {
/* Location is a special case */
gchar *str = (gchar *)xmlNodeGetContent(nptr);
if (strstr (str, "://") != NULL)
location = str_get (str);
else if (str[0] == '/' && base != NULL)
{
const gchar * colon = strstr (base, "://");
if (colon != NULL)
location = str_printf ("%.*s%s", (gint) (colon + 3 -
base), base, str);
}
else if (base != NULL)
{
const gchar * slash = strrchr (base, '/');
if (slash != NULL)
location = str_printf ("%.*s%s", (gint) (slash + 1 -
base), base, str);
}
xmlFree(str);
} else {
/* Rest of the nodes are handled here */
gint i;
gboolean isMeta;
xmlChar *findName;
if (!xmlStrcmp(nptr->name, (xmlChar *)"meta")) {
isMeta = TRUE;
findName = xmlGetProp(nptr, (xmlChar *)"rel");
} else {
isMeta = FALSE;
findName = xmlStrdup(nptr->name);
}
for (i = 0; i < xspf_nentries; i++)
if ((xspf_entries[i].isMeta == isMeta) &&
!xmlStrcmp(findName, (xmlChar *)xspf_entries[i].xspfName)) {
xmlChar *str = xmlNodeGetContent(nptr);
switch (xspf_entries[i].type) {
case TUPLE_STRING:
if (! tuple)
tuple = tuple_new ();
tuple_set_str(tuple, xspf_entries[i].tupleField, NULL, (gchar *)str);
break;
case TUPLE_INT:
if (! tuple)
tuple = tuple_new ();
tuple_set_int(tuple, xspf_entries[i].tupleField, NULL, atol((char *)str));
break;
default:
break;
}
xmlFree(str);
break;
}
xmlFree(findName);
}
}
}
if (location != NULL)
{
if (tuple)
tuple_set_filename (tuple, location);
index_append(filenames, location);
index_append(tuples, tuple);
}
else if (tuple)
tuple_unref (tuple);
}
void drct_pl_open_temp (const char * filename)
{
Index * filenames = index_new ();
index_append (filenames, str_get (filename));
add_list (filenames, -1, TRUE, TRUE);
}
void drct_pl_open (const char * filename)
{
Index * filenames = index_new ();
index_append (filenames, str_get (filename));
add_list (filenames, -1, get_bool (NULL, "open_to_temporary"), TRUE);
}
void drct_pl_add (const char * filename, int at)
{
Index * filenames = index_new ();
index_append (filenames, str_get (filename));
add_list (filenames, at, FALSE, FALSE);
}
Index * equalizer_read_presets (const char * basename)
{
char *filename, *name;
GKeyFile *rcfile;
GError *error = NULL;
int i, p = 0;
EqualizerPreset *preset;
filename = g_build_filename (get_path (AUD_PATH_USER_DIR), basename, NULL);
rcfile = g_key_file_new();
if (!g_key_file_load_from_file(rcfile, filename, G_KEY_FILE_NONE, &error))
{
g_free(filename);
filename = g_build_filename (get_path (AUD_PATH_DATA_DIR), basename,
NULL);
error = NULL;
if (!g_key_file_load_from_file(rcfile, filename, G_KEY_FILE_NONE, &error))
{
g_free(filename);
return NULL;
}
}
g_free(filename);
Index * list = index_new ();
for (;;)
{
char section[32];
error = NULL;
g_snprintf(section, sizeof(section), "Preset%d", p++);
if ((name = g_key_file_get_string(rcfile, "Presets", section, &error)) != NULL)
{
error = NULL;
preset = g_new0(EqualizerPreset, 1);
preset->name = name;
preset->preamp = g_key_file_get_double(rcfile, name, "Preamp", &error);
for (i = 0; i < AUD_EQUALIZER_NBANDS; i++)
{
char band[16];
g_snprintf(band, sizeof(band), "Band%d", i);
error = NULL;
preset->bands[i] = g_key_file_get_double(rcfile, name, band, &error);
}
index_append (list, preset);
}
else
break;
}
g_key_file_free(rcfile);
return list;
}
void pw_col_choose (void)
{
if (window)
{
gtk_window_present ((GtkWindow *) window);
return;
}
chosen = index_new ();
avail = index_new ();
gboolean added[PW_COLS];
memset (added, 0, sizeof added);
for (gint i = 0; i < pw_num_cols; i ++)
{
if (added[pw_cols[i]])
continue;
added[pw_cols[i]] = TRUE;
Column * column = g_slice_new (Column);
column->column = pw_cols[i];
column->selected = 0;
index_append (chosen, column);
}
for (gint i = 0; i < PW_COLS; i ++)
{
if (added[i])
continue;
Column * column = g_slice_new (Column);
column->column = i;
column->selected = 0;
index_append (avail, column);
}
window = gtk_dialog_new_with_buttons (_("Choose Columns"), NULL, 0,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
NULL);
gtk_window_set_default_size ((GtkWindow *) window, 400, 300);
gtk_dialog_set_default_response ((GtkDialog *) window, GTK_RESPONSE_ACCEPT);
g_signal_connect (window, "response", (GCallback) response_cb, NULL);
g_signal_connect (window, "destroy", (GCallback) destroy_cb, NULL);
GtkWidget * hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start ((GtkBox *) gtk_dialog_get_content_area ((GtkDialog *)
window), hbox, TRUE, TRUE, 0);
GtkWidget * vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
gtk_box_pack_start ((GtkBox *) hbox, vbox, TRUE, TRUE, 0);
GtkWidget * label = gtk_label_new (_("Available:"));
g_object_set ((GObject *) label, "xalign", (gfloat) 0, NULL);
gtk_box_pack_start ((GtkBox *) vbox, label, FALSE, FALSE, 0);
GtkWidget * scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy ((GtkScrolledWindow *) scroll,
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type ((GtkScrolledWindow *) scroll,
GTK_SHADOW_IN);
gtk_box_pack_start ((GtkBox *) vbox, scroll, TRUE, TRUE, 0);
avail_list = audgui_list_new (& callbacks, avail, index_count (avail));
gtk_tree_view_set_headers_visible ((GtkTreeView *) avail_list, FALSE);
audgui_list_add_column (avail_list, NULL, 0, G_TYPE_STRING, -1);
gtk_container_add ((GtkContainer *) scroll, avail_list);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start ((GtkBox *) hbox, vbox, FALSE, FALSE, 0);
GtkWidget * button = gtk_button_new ();
gtk_container_add ((GtkContainer *) button, gtk_image_new_from_stock
(GTK_STOCK_GO_FORWARD, GTK_ICON_SIZE_BUTTON));
gtk_box_pack_start ((GtkBox *) vbox, button, TRUE, FALSE, 0);
g_signal_connect_swapped (button, "clicked", (GCallback) transfer, avail);
button = gtk_button_new ();
gtk_container_add ((GtkContainer *) button, gtk_image_new_from_stock
(GTK_STOCK_GO_BACK, GTK_ICON_SIZE_BUTTON));
gtk_box_pack_start ((GtkBox *) vbox, button, TRUE, FALSE, 0);
g_signal_connect_swapped (button, "clicked", (GCallback) transfer, chosen);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
gtk_box_pack_start ((GtkBox *) hbox, vbox, TRUE, TRUE, 0);
label = gtk_label_new (_("Chosen:"));
g_object_set ((GObject *) label, "xalign", (gfloat) 0, NULL);
gtk_box_pack_start ((GtkBox *) vbox, label, FALSE, FALSE, 0);
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy ((GtkScrolledWindow *) scroll,
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type ((GtkScrolledWindow *) scroll,
GTK_SHADOW_IN);
gtk_box_pack_start ((GtkBox *) vbox, scroll, TRUE, TRUE, 0);
chosen_list = audgui_list_new (& callbacks, chosen, index_count (chosen));
gtk_tree_view_set_headers_visible ((GtkTreeView *) chosen_list, FALSE);
audgui_list_add_column (chosen_list, NULL, 0, G_TYPE_STRING, -1);
gtk_container_add ((GtkContainer *) scroll, chosen_list);
gtk_widget_show_all (window);
}
/*
* Port table
*/
int
op_snmp_port(struct snmp_context *ctx, struct snmp_value *value,
u_int sub, u_int iidx, enum snmp_op op)
{
asn_subid_t which = value->var.subs[sub-1];
struct udp_port *p;
u_int8_t addr[4];
u_int32_t port;
switch (op) {
case SNMP_OP_GETNEXT:
if ((p = (struct udp_port *)trans_next_port(my_trans,
&value->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
index_append(&value->var, sub, &p->tport.index);
break;
case SNMP_OP_GET:
if ((p = (struct udp_port *)trans_find_port(my_trans,
&value->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
break;
case SNMP_OP_SET:
p = (struct udp_port *)trans_find_port(my_trans,
&value->var, sub);
ctx->scratch->int1 = (p != NULL);
if (which != LEAF_begemotSnmpdPortStatus)
abort();
if (!TRUTH_OK(value->v.integer))
return (SNMP_ERR_WRONG_VALUE);
ctx->scratch->int2 = TRUTH_GET(value->v.integer);
if (ctx->scratch->int2) {
/* open an SNMP port */
if (p != NULL)
/* already open - do nothing */
return (SNMP_ERR_NOERROR);
if (index_decode(&value->var, sub, iidx, addr, &port))
return (SNMP_ERR_NO_CREATION);
return (udp_open_port(addr, port, &p));
} else {
/* close SNMP port - do in commit */
}
return (SNMP_ERR_NOERROR);
case SNMP_OP_ROLLBACK:
p = (struct udp_port *)trans_find_port(my_trans,
&value->var, sub);
if (ctx->scratch->int1 == 0) {
/* did not exist */
if (ctx->scratch->int2 == 1) {
/* created */
if (p != NULL)
udp_close_port(&p->tport);
}
}
return (SNMP_ERR_NOERROR);
case SNMP_OP_COMMIT:
p = (struct udp_port *)trans_find_port(my_trans,
&value->var, sub);
if (ctx->scratch->int1 == 1) {
/* did exist */
if (ctx->scratch->int2 == 0) {
/* delete */
if (p != NULL)
udp_close_port(&p->tport);
}
}
return (SNMP_ERR_NOERROR);
default:
abort();
}
/*
* Come here to fetch the value
*/
switch (which) {
case LEAF_begemotSnmpdPortStatus:
value->v.integer = 1;
break;
default:
abort();
}
return (SNMP_ERR_NOERROR);
}
static void start_plugin (LoadedPlugin * loaded)
{
if (loaded->active)
return;
loaded->active = 1;
PluginData * plugin = loaded->plugin;
const LADSPA_Descriptor * desc = plugin->desc;
int ports = plugin->in_ports->len;
if (ports == 0 || ports != plugin->out_ports->len)
{
fprintf (stderr, "Plugin has unusable port configuration: %s\n", desc->Name);
return;
}
if (ladspa_channels % ports != 0)
{
fprintf (stderr, "Plugin cannot be used with %d channels: %s\n",
ladspa_channels, desc->Name);
return;
}
int instances = ladspa_channels / ports;
loaded->instances = index_new ();
loaded->in_bufs = g_malloc (sizeof (float *) * ladspa_channels);
loaded->out_bufs = g_malloc (sizeof (float *) * ladspa_channels);
for (int i = 0; i < instances; i ++)
{
LADSPA_Handle handle = desc->instantiate (desc, ladspa_rate);
index_append (loaded->instances, handle);
int controls = index_count (plugin->controls);
for (int c = 0; c < controls; c ++)
{
ControlData * control = index_get (plugin->controls, c);
desc->connect_port (handle, control->port, & loaded->values[c]);
}
for (int p = 0; p < ports; p ++)
{
int channel = ports * i + p;
float * in = g_malloc (sizeof (float) * LADSPA_BUFLEN);
loaded->in_bufs[channel] = in;
int in_port = g_array_index (plugin->in_ports, int, p);
desc->connect_port (handle, in_port, in);
float * out = g_malloc (sizeof (float) * LADSPA_BUFLEN);
loaded->out_bufs[channel] = out;
int out_port = g_array_index (plugin->out_ports, int, p);
desc->connect_port (handle, out_port, out);
}
if (desc->activate)
desc->activate (handle);
}
}
