static void begin_add (const char * path)
{
int list = get_playlist (FALSE, FALSE);
if (list < 0)
list = create_playlist ();
aud_set_str ("search-tool", "path", path);
char * uri = filename_to_uri (path);
g_return_if_fail (uri);
if (! g_str_has_suffix (uri, "/"))
{
SCONCAT2 (temp, uri, "/");
str_unref (uri);
uri = str_get (temp);
}
destroy_added_table ();
added_table = g_hash_table_new_full ((GHashFunc) str_hash, (GEqualFunc)
str_equal, (GDestroyNotify) str_unref, NULL);
int entries = aud_playlist_entry_count (list);
for (int entry = 0; entry < entries; entry ++)
{
char * filename = aud_playlist_entry_get_filename (list, entry);
if (g_str_has_prefix (filename, uri) && ! g_hash_table_contains (added_table, filename))
{
aud_playlist_entry_set_selected (list, entry, FALSE);
g_hash_table_insert (added_table, filename, NULL);
}
else
{
aud_playlist_entry_set_selected (list, entry, TRUE);
str_unref (filename);
}
}
aud_playlist_delete_selected (list);
aud_playlist_remove_failed (list);
Index * add = index_new ();
index_insert (add, -1, uri);
aud_playlist_entry_insert_filtered (list, -1, add, NULL, filter_cb, NULL, FALSE);
adding = TRUE;
}
VFSFile * open_local_file_nocase (const char * folder, const char * basename)
{
char * path = find_file_case_path (folder, basename);
if (! path)
return NULL;
char * uri = filename_to_uri (path);
g_free (path);
if (! uri)
return NULL;
VFSFile * file = vfs_fopen (uri, "r");
str_unref (uri);
return file;
}
gboolean write_and_pivot_files (vcedit_state * state)
{
gchar * temp;
GError * error;
gint handle = g_file_open_tmp (NULL, & temp, & error);
if (handle < 0)
{
fprintf (stderr, "Failed to create temp file: %s.\n", error->message);
g_error_free (error);
return FALSE;
}
close (handle);
gchar * temp_uri = filename_to_uri (temp);
g_return_val_if_fail (temp_uri, FALSE);
VFSFile * temp_vfs = vfs_fopen (temp_uri, "r+");
g_return_val_if_fail (temp_vfs, FALSE);
str_unref (temp_uri);
if (vcedit_write (state, temp_vfs) < 0)
{
fprintf (stderr, "Tag update failed: %s.\n", state->lasterror);
vfs_fclose (temp_vfs);
g_free (temp);
return FALSE;
}
if (! copy_vfs (temp_vfs, state->in))
{
fprintf (stderr, "Failed to copy temp file. The temp file has not "
"been deleted: %s.\n", temp);
vfs_fclose (temp_vfs);
g_free (temp);
return FALSE;
}
vfs_fclose (temp_vfs);
if (g_unlink (temp) < 0)
fprintf (stderr, "Failed to delete temp file: %s.\n", temp);
g_free (temp);
return TRUE;
}
char * construct_uri (const char * path, const char * reference)
{
/* URI */
if (strstr (path, "://"))
return str_get (path);
/* absolute filename */
#ifdef _WIN32
if (path[0] && path[1] == ':' && path[2] == '\\')
#else
if (path[0] == '/')
#endif
return filename_to_uri (path);
/* relative path */
const char * slash = strrchr (reference, '/');
if (! slash)
return NULL;
char * utf8 = str_to_utf8 (path, -1);
if (! utf8)
return NULL;
int pathlen = slash + 1 - reference;
char buf[pathlen + 3 * strlen (utf8) + 1];
memcpy (buf, reference, pathlen);
if (get_bool (NULL, "convert_backslash"))
{
SCOPY (tmp, utf8);
str_replace_char (tmp, '\\', '/');
str_encode_percent (tmp, -1, buf + pathlen);
}
else
str_encode_percent (utf8, -1, buf + pathlen);
str_unref (utf8);
return str_get (buf);
}
char * construct_uri (const char * string, const char * playlist_name)
{
/* URI */
if (strstr (string, "://"))
return strdup (string);
/* absolute filename (assumed UTF-8) */
#ifdef _WIN32
if (string[0] && string[1] == ':' && string[2] == '\\')
#else
if (string[0] == '/')
#endif
return filename_to_uri (string);
/* relative filename (assumed UTF-8) */
const char * slash = strrchr (playlist_name, '/');
if (! slash)
return NULL;
int pathlen = slash + 1 - playlist_name;
int rellen = strlen (string);
char buf[pathlen + 3 * rellen + 1];
memcpy (buf, playlist_name, pathlen);
if (get_bool (NULL, "convert_backslash"))
{
char tmp[rellen + 1];
strcpy (tmp, string);
string_replace_char (tmp, '\\', '/');
str_encode_percent (tmp, -1, buf + pathlen);
}
else
str_encode_percent (string, -1, buf + pathlen);
return strdup (buf);
}
char * get_associated_image_file (const char * filename)
{
char * image_uri = NULL;
char * local = uri_to_filename (filename);
char * base = local ? last_path_element (local) : NULL;
if (local && base)
{
char * include = get_str (NULL, "cover_name_include");
char * exclude = get_str (NULL, "cover_name_exclude");
SearchParams params = {
.basename = base,
.include = str_list_to_index (include, ", "),
.exclude = str_list_to_index (exclude, ", ")
};
str_unref (include);
str_unref (exclude);
SNCOPY (path, local, base - 1 - local);
char * image_local = fileinfo_recursive_get_image (path, & params, 0);
if (image_local)
image_uri = filename_to_uri (image_local);
str_unref (image_local);
index_free_full (params.include, (IndexFreeFunc) str_unref);
index_free_full (params.exclude, (IndexFreeFunc) str_unref);
}
str_unref (local);
return image_uri;
}
static gboolean file_init (void)
{
aud_config_set_defaults ("filewriter", filewriter_defaults);
fileext = aud_get_int ("filewriter", "fileext");
filenamefromtags = aud_get_bool ("filewriter", "filenamefromtags");
file_path = aud_get_str ("filewriter", "file_path");
prependnumber = aud_get_bool ("filewriter", "prependnumber");
save_original = aud_get_bool ("filewriter", "save_original");
use_suffix = aud_get_bool ("filewriter", "use_suffix");
if (! file_path[0])
{
str_unref (file_path);
file_path = filename_to_uri (g_get_home_dir ());
g_return_val_if_fail (file_path != NULL, FALSE);
}
set_plugin();
if (plugin->init)
plugin->init(&file_write_output);
return TRUE;
}
static void save_playlists_real (void)
{
int lists = playlist_count ();
const char * folder = get_path (AUD_PATH_PLAYLISTS_DIR);
/* save playlists */
char * * order = g_malloc (sizeof (char *) * (lists + 1));
GHashTable * saved = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
for (int i = 0; i < lists; i ++)
{
int id = playlist_get_unique_id (i);
order[i] = g_strdup_printf ("%d", id);
if (playlist_get_modified (i))
{
char * path = g_strdup_printf ("%s/%d.audpl", folder, id);
char * uri = filename_to_uri (path);
playlist_save (i, uri);
playlist_set_modified (i, FALSE);
g_free (path);
g_free (uri);
}
g_hash_table_insert (saved, g_strdup_printf ("%d.audpl", id), NULL);
}
order[lists] = NULL;
char * order_string = g_strjoinv (" ", order);
g_strfreev (order);
GError * error = NULL;
char * order_path = g_strdup_printf ("%s/order", get_path (AUD_PATH_PLAYLISTS_DIR));
char * old_order_string;
g_file_get_contents (order_path, & old_order_string, NULL, NULL);
if (! old_order_string || strcmp (old_order_string, order_string))
{
if (! g_file_set_contents (order_path, order_string, -1, & error))
{
fprintf (stderr, "Cannot write to %s: %s\n", order_path, error->message);
g_error_free (error);
}
}
g_free (order_string);
g_free (order_path);
g_free (old_order_string);
/* clean up deleted playlists and files from old naming scheme */
char * path = make_playlist_path (0);
remove (path);
g_free (path);
DIR * dir = opendir (folder);
if (! dir)
goto DONE;
struct dirent * entry;
while ((entry = readdir (dir)))
{
if (! g_str_has_suffix (entry->d_name, ".audpl")
&& ! g_str_has_suffix (entry->d_name, ".xspf"))
continue;
if (! g_hash_table_lookup_extended (saved, entry->d_name, NULL, NULL))
{
char * path = g_strdup_printf ("%s/%s", folder, entry->d_name);
remove (path);
g_free (path);
}
}
closedir (dir);
DONE:
g_hash_table_destroy (saved);
}
static void load_playlists_real (void)
{
/* old (v3.1 and earlier) naming scheme */
int count;
for (count = 0; ; count ++)
{
char * path = make_playlist_path (count);
if (! g_file_test (path, G_FILE_TEST_EXISTS))
{
g_free (path);
break;
}
char * uri = filename_to_uri (path);
playlist_insert (count);
playlist_insert_playlist_raw (count, 0, uri);
playlist_set_modified (count, TRUE);
g_free (path);
g_free (uri);
}
/* unique ID-based naming scheme */
char * order_path = g_strdup_printf ("%s/order", get_path (AUD_PATH_PLAYLISTS_DIR));
char * order_string;
g_file_get_contents (order_path, & order_string, NULL, NULL);
g_free (order_path);
if (! order_string)
goto DONE;
char * * order = g_strsplit (order_string, " ", -1);
g_free (order_string);
for (int i = 0; order[i]; i ++)
{
char * path = g_strdup_printf ("%s/%s.audpl", get_path (AUD_PATH_PLAYLISTS_DIR), order[i]);
if (! g_file_test (path, G_FILE_TEST_EXISTS))
{
g_free (path);
path = g_strdup_printf ("%s/%s.xspf", get_path (AUD_PATH_PLAYLISTS_DIR), order[i]);
}
char * uri = filename_to_uri (path);
playlist_insert_with_id (count + i, atoi (order[i]));
playlist_insert_playlist_raw (count + i, 0, uri);
playlist_set_modified (count + i, FALSE);
if (g_str_has_suffix (path, ".xspf"))
playlist_set_modified (count + i, TRUE);
g_free (path);
g_free (uri);
}
g_strfreev (order);
DONE:
if (! playlist_count ())
playlist_insert (0);
playlist_set_active (0);
}
