void audgui_infowin_show (int playlist, int entry)
{
char * filename = aud_playlist_entry_get_filename (playlist, entry);
g_return_if_fail (filename != NULL);
PluginHandle * decoder = aud_playlist_entry_get_decoder (playlist, entry,
FALSE);
if (decoder == NULL)
goto FREE;
if (aud_custom_infowin (filename, decoder))
goto FREE;
Tuple * tuple = aud_playlist_entry_get_tuple (playlist, entry, FALSE);
if (tuple == NULL)
{
char * message = g_strdup_printf (_("No info available for %s.\n"),
filename);
aud_interface_show_error (message);
g_free (message);
goto FREE;
}
infowin_show (playlist, entry, filename, tuple, decoder,
aud_file_can_write_tuple (filename, decoder));
tuple_unref (tuple);
FREE:
str_unref (filename);
}
static void do_add (bool_t play, char * * title)
{
int list = aud_playlist_by_unique_id (playlist_id);
int n_items = index_count (items);
int n_selected = 0;
Index * filenames = index_new ();
Index * tuples = index_new ();
for (int i = 0; i < n_items; i ++)
{
if (! selection->data[i])
continue;
Item * item = index_get (items, i);
for (int m = 0; m < item->matches->len; m ++)
{
int entry = g_array_index (item->matches, int, m);
index_insert (filenames, -1, aud_playlist_entry_get_filename (list, entry));
index_insert (tuples, -1, aud_playlist_entry_get_tuple (list, entry, TRUE));
}
n_selected ++;
if (title && n_selected == 1)
* title = item->name;
}
if (title && n_selected != 1)
* title = NULL;
aud_playlist_entry_insert_batch (aud_playlist_get_active (), -1, filenames,
tuples, play);
}
static void ready (void *hook_data, void *user_data) {
cleanup_current_track();
Tuple *current_track = aud_playlist_entry_get_tuple(aud_playlist_get_playing(), aud_playlist_get_position(aud_playlist_get_playing()), FALSE);
int duration_seconds = tuple_get_int(current_track, FIELD_LENGTH) / 1000;
if (duration_seconds <= 30) {
tuple_unref(current_track);
return;
}
pthread_mutex_lock(&communication_mutex);
now_playing_track = tuple_ref(current_track);
now_playing_requested = TRUE;
pthread_cond_signal(&communication_signal);
pthread_mutex_unlock(&communication_mutex);
time_until_scrobble = (((gint64)duration_seconds)*G_USEC_PER_SEC) / 2;
if (time_until_scrobble > 4*60*G_USEC_PER_SEC) {
time_until_scrobble = 4*60*G_USEC_PER_SEC;
}
timestamp = g_get_real_time() / G_USEC_PER_SEC;
play_started_at = g_get_monotonic_time();
playing_track = current_track;
queue_function_ID = g_timeout_add_seconds(time_until_scrobble / G_USEC_PER_SEC, (GSourceFunc) queue_track_to_scrobble, NULL);
}
gboolean checkcover (gint tag) {
gint playlist_position;
//gchar *playlist_uri = NULL;
gchar *playlist_filename = NULL;
gint playlist = aud_playlist_get_active();
gboolean processed = 0;
gboolean fast_call = 0;
gdk_threads_enter ();
playlist_position = aud_playlist_get_position(playlist);
//playlist_uri = aud_playlist_get_filename (playlist);
const Tuple *tuple = aud_playlist_entry_get_tuple(playlist, playlist_position, fast_call);
if (tuple)
{
playlist_filename = g_strdup((gchar *) tuple_get_string(tuple, FIELD_FILE_PATH, NULL));
if (playlist_filename)
{
/*playlist_filename = g_filename_from_uri(playlist_uri, NULL, NULL);
if (playlist_filename)
{*/
if (strcmp (playlist_filename,current_filename) && !mainwindow_data.loading_cover)
{
mainwindow_data.loading_cover = TRUE;
// Filename has changed
current_filename = realloc (current_filename,strlen(playlist_filename)+1);
strcpy (current_filename,playlist_filename);
DPRINT (__DEBUG_GENERAL__,"New playfile detected: %s",current_filename);
// Find new cover if possible
findcover_search (current_filename);
DPRINT (__DEBUG_GENERAL__,"Cover to display: %s",findcover_filename);
loadimage (findcover_filename);
mainwindow_data.loading_cover = FALSE;
}
free (playlist_filename);
//free (playlist_uri);
processed = 1;
/*}*/
}
}
if (!processed)
{
mainwindow_data.loading_cover = TRUE;
loadimage (NULL);
mainwindow_data.loading_cover = FALSE;
}
gdk_threads_leave ();
return TRUE;
}
GList *
get_upload_list(void)
{
GList *up_list=NULL;
gint current_play = aud_playlist_get_active();
gint i = (aud_playlist_entry_count(current_play) - 1);
for (; i >= 0; i--)
{
if (aud_playlist_entry_get_selected(current_play, i))
{
Tuple * tuple = aud_playlist_entry_get_tuple (current_play, i, FALSE);
aud_playlist_entry_set_selected(current_play, i, FALSE);
up_list = g_list_prepend (up_list, (void *) tuple);
if (tuple)
tuple_unref (tuple);
}
}
return g_list_reverse(up_list);
}
static gint file_open(gint fmt, gint rate, gint nch)
{
gchar *filename = NULL, *temp = NULL;
gchar * directory;
gint pos;
gint rv;
gint playlist;
input.format = fmt;
input.frequency = rate;
input.channels = nch;
playlist = aud_playlist_get_playing ();
if (playlist < 0)
return 0;
pos = aud_playlist_get_position(playlist);
tuple = aud_playlist_entry_get_tuple (playlist, pos, FALSE);
if (tuple == NULL)
return 0;
if (filenamefromtags)
{
gchar * utf8 = aud_playlist_entry_get_title (playlist, pos, FALSE);
string_replace_char (utf8, '/', ' ');
gchar buf[3 * strlen (utf8) + 1];
str_encode_percent (utf8, -1, buf);
str_unref (utf8);
filename = g_strdup (buf);
}
else
{
temp = aud_playlist_entry_get_filename (playlist, pos);
gchar * original = strrchr (temp, '/');
g_return_val_if_fail (original != NULL, 0);
filename = g_strdup (original + 1);
str_unref (temp);
if (!use_suffix)
if ((temp = strrchr(filename, '.')) != NULL)
*temp = '\0';
}
if (prependnumber)
{
gint number = tuple_get_int(tuple, FIELD_TRACK_NUMBER, NULL);
if (!tuple || !number)
number = pos + 1;
temp = g_strdup_printf ("%d%%20%s", number, filename);
g_free(filename);
filename = temp;
}
if (save_original)
{
temp = aud_playlist_entry_get_filename (playlist, pos);
directory = g_strdup (temp);
str_unref (temp);
temp = strrchr (directory, '/');
g_return_val_if_fail (temp != NULL, 0);
temp[1] = 0;
}
else
{
g_return_val_if_fail (file_path[0], 0);
if (file_path[strlen (file_path) - 1] == '/')
directory = g_strdup (file_path);
else
directory = g_strdup_printf ("%s/", file_path);
}
temp = g_strdup_printf ("%s%s.%s", directory, filename, fileext_str[fileext]);
g_free (directory);
g_free (filename);
filename = temp;
output_file = safe_create (filename);
g_free (filename);
if (output_file == NULL)
return 0;
convert_init (fmt, plugin->format_required (fmt), nch);
rv = (plugin->open)();
samples_written = 0;
return rv;
}
static void get_value (void * user, gint row, gint column, GValue * value)
{
PlaylistWidgetData * data = user;
g_return_if_fail (column >= 0 && column < pw_num_cols);
g_return_if_fail (row >= 0 && row < aud_playlist_entry_count (data->list));
column = pw_cols[column];
gchar * title = NULL, * artist = NULL, * album = NULL;
Tuple * tuple = NULL;
if (column == PW_COL_TITLE || column == PW_COL_ARTIST || column ==
PW_COL_ALBUM)
aud_playlist_entry_describe (data->list, row, & title, & artist,
& album, TRUE);
else if (column == PW_COL_YEAR || column == PW_COL_TRACK || column ==
PW_COL_GENRE || column == PW_COL_FILENAME || column == PW_COL_PATH ||
column == PW_COL_BITRATE)
tuple = aud_playlist_entry_get_tuple (data->list, row, TRUE);
switch (column)
{
case PW_COL_NUMBER:
g_value_set_int (value, 1 + row);
break;
case PW_COL_TITLE:
g_value_set_string (value, title);
break;
case PW_COL_ARTIST:
g_value_set_string (value, artist);
break;
case PW_COL_YEAR:
set_int_from_tuple (value, tuple, FIELD_YEAR);
break;
case PW_COL_ALBUM:
g_value_set_string (value, album);
break;
case PW_COL_TRACK:
set_int_from_tuple (value, tuple, FIELD_TRACK_NUMBER);
break;
case PW_COL_GENRE:
set_string_from_tuple (value, tuple, FIELD_GENRE);
break;
case PW_COL_QUEUED:
set_queued (value, data->list, row);
break;
case PW_COL_LENGTH:
set_length (value, data->list, row);
break;
case PW_COL_FILENAME:
set_string_from_tuple (value, tuple, FIELD_FILE_NAME);
break;
case PW_COL_PATH:
set_string_from_tuple (value, tuple, FIELD_FILE_PATH);
break;
case PW_COL_CUSTOM:;
gchar * custom = aud_playlist_entry_get_title (data->list, row, TRUE);
g_value_set_string (value, custom);
str_unref (custom);
break;
case PW_COL_BITRATE:
set_int_from_tuple (value, tuple, FIELD_BITRATE);
break;
}
str_unref (title);
str_unref (artist);
str_unref (album);
if (tuple)
tuple_unref (tuple);
}
/* do_command(): do @cmd after replacing the format codes
@cmd: command to run */
static void do_command (char * cmd)
{
int playlist = aud_playlist_get_playing ();
int pos = aud_playlist_get_position (playlist);
char *shstring = NULL, *temp, numbuf[32];
gboolean playing;
Formatter *formatter;
if (cmd && strlen(cmd) > 0)
{
formatter = formatter_new();
char * ctitle = aud_playlist_entry_get_title (playlist, pos, FALSE);
if (ctitle)
{
temp = escape_shell_chars (ctitle);
formatter_associate(formatter, 's', temp);
formatter_associate(formatter, 'n', temp);
g_free(temp);
str_unref (ctitle);
}
else
{
formatter_associate(formatter, 's', "");
formatter_associate(formatter, 'n', "");
}
char * filename = aud_playlist_entry_get_filename (playlist, pos);
if (filename)
{
temp = escape_shell_chars (filename);
formatter_associate(formatter, 'f', temp);
g_free(temp);
str_unref (filename);
}
else
formatter_associate(formatter, 'f', "");
g_snprintf(numbuf, sizeof(numbuf), "%02d", pos + 1);
formatter_associate(formatter, 't', numbuf);
int length = aud_playlist_entry_get_length (playlist, pos, FALSE);
if (length > 0)
{
g_snprintf(numbuf, sizeof(numbuf), "%d", length);
formatter_associate(formatter, 'l', numbuf);
}
else
formatter_associate(formatter, 'l', "0");
playing = aud_drct_get_playing();
g_snprintf(numbuf, sizeof(numbuf), "%d", playing);
formatter_associate(formatter, 'p', numbuf);
if (playing)
{
int brate, srate, chans;
aud_drct_get_info (& brate, & srate, & chans);
snprintf (numbuf, sizeof numbuf, "%d", brate);
formatter_associate (formatter, 'r', numbuf);
snprintf (numbuf, sizeof numbuf, "%d", srate);
formatter_associate (formatter, 'F', numbuf);
snprintf (numbuf, sizeof numbuf, "%d", chans);
formatter_associate (formatter, 'c', numbuf);
}
Tuple * tuple = aud_playlist_entry_get_tuple
(aud_playlist_get_active (), pos, 0);
char * artist = tuple ? tuple_get_str (tuple, FIELD_ARTIST, NULL) : NULL;
if (artist)
{
formatter_associate(formatter, 'a', artist);
str_unref(artist);
}
else
formatter_associate(formatter, 'a', "");
char * album = tuple ? tuple_get_str (tuple, FIELD_ALBUM, NULL) : NULL;
if (album)
{
formatter_associate(formatter, 'b', album);
str_unref(album);
}
else
formatter_associate(formatter, 'b', "");
char * title = tuple ? tuple_get_str (tuple, FIELD_TITLE, NULL) : NULL;
if (title)
{
formatter_associate(formatter, 'T', title);
str_unref(title);
}
else
formatter_associate(formatter, 'T', "");
if (tuple)
tuple_unref (tuple);
shstring = formatter_format(formatter, cmd);
formatter_destroy(formatter);
if (shstring)
{
execute_command(shstring);
/* FIXME: This can possibly be freed too early */
g_free(shstring);
}
}
}
